test: replace unsecure function with secure function

Signed-off-by: Nxuxinyu <xuxinyu6@huawei.com>
Change-Id: Ie120ffa529798f0f087ddfcd34f5d9c5802b6766

testsuites/kernel/include/osTest.h

@@ -86,14 +86,14 @@ extern "C" {
 #endif /* __cpluscplus */
 #endif /* __cpluscplus */
 
-#define TEST_TASK_PARAM_INIT(testTask, task_name, entry, prio)     \
-    do {                                                           \
-        memset(&testTask, 0, sizeof(TSK_INIT_PARAM_S));            \
-        testTask.pfnTaskEntry = (TSK_ENTRY_FUNC)entry;             \
-        testTask.uwStackSize = 0x1000;                             \
-        testTask.pcName = task_name;                               \
-        testTask.usTaskPrio = prio;                                \
-        testTask.uwResved = LOS_TASK_STATUS_DETACHED;              \
+#define TEST_TASK_PARAM_INIT(testTask, task_name, entry, prio)                              \
+    do {                                                                                    \
+        (void)memset_s(&(testTask), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S)); \
+        testTask.pfnTaskEntry = (TSK_ENTRY_FUNC)entry;                                      \
+        testTask.uwStackSize = 0x1000;                                                      \
+        testTask.pcName = task_name;                                                        \
+        testTask.usTaskPrio = prio;                                                         \
+        testTask.uwResved = LOS_TASK_STATUS_DETACHED;                                       \
     } while (0);
 
 #ifdef LOSCFG_KERNEL_SMP

testsuites/kernel/sample/kernel_base/core/hwi_nesting/It_hwi_nesting.c

@@ -50,7 +50,7 @@ VOID RecordIntrTrace(INT32 irq, INT32 direction)
 VOID ResetIntrTrace(VOID)
 {
     g_traceIdx = 0;
-    memset(g_intrTrace, 0, RECORD_SIZE);
+    (void)memset_s(g_intrTrace, RECORD_SIZE, 0, RECORD_SIZE);
 }
 
 UINT32 CheckIntrTrace(UINT32 *expect, UINT32 num)

testsuites/kernel/sample/kernel_base/core/hwi_nesting/full/It_los_hwi_nesting_006.c

@@ -44,7 +44,7 @@ static VOID NestingPrioHigh(INT32 irq, VOID *data)
 {
     g_intrHandleEnd = 1;
     UINT32 temp[0x100][2] = {0};
-    memset(temp, 1, sizeof(UINT32) * 0x100 * 2); // 2, buffer size.
+    (void)memset_s(temp, sizeof(UINT32) * 0x100 * 2, 1, sizeof(UINT32) * 0x100 * 2); // 2, buffer size.
 }
 
 static VOID TaskF01(VOID)

testsuites/kernel/sample/kernel_base/core/task/full/It_los_task_040.c

@@ -58,7 +58,7 @@ static UINT32 Testcase(void)
     // 32, number of cycles
     for (index = 0; index < 32; index++) {
         task1.usTaskPrio = index;
-        snprintf(acName, 10, "Tsk040A%2d", index); // 10, snprintf size.
+        (void)snprintf_s(acName, TASK_NAME_NUM, TASK_NAME_NUM - 1, "Tsk040A%2d", index);
         task1.pcName = acName;
         task1.uwResved = LOS_TASK_STATUS_DETACHED;
 

testsuites/kernel/sample/kernel_base/core/task/full/It_los_task_082.c

@@ -58,9 +58,10 @@ EXIT:
 static UINT32 Testcase(void)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
+
     LOS_EventInit(&g_eventCb01);
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "Tsk082A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/core/task/full/It_los_task_118.c

@@ -142,7 +142,8 @@ static UINT32 Testcase(void)
     ret = LOS_TaskCreate(&g_testTaskID01, &task1);
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s(&task1, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF02;
     task1.uwStackSize = TASK_STACK_SIZE_TEST;
     task1.pcName = "Tsk118B";

testsuites/kernel/sample/kernel_base/core/task/full/It_los_task_138.c

@@ -142,7 +142,8 @@ static UINT32 Testcase(void)
     ret = LOS_TaskCreate(&g_testTaskID01, &task1);
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s(&task1, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF02;
     task1.uwStackSize = TASK_STACK_SIZE_TEST;
     task1.pcName = "Tsk118B";

testsuites/kernel/sample/kernel_base/core/task/smp/It_smp_los_task_024.c

@@ -80,7 +80,8 @@ static UINT32 Testcase(void)
     currCpuid = (ArchCurrCpuid() + 1) % LOSCFG_KERNEL_CORE_NUM;
 #endif
 
-    memset(&task, 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s(&task, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     task.pfnTaskEntry = (TSK_ENTRY_FUNC)ItTimeslice001F01;
     task.usTaskPrio = TASK_PRIO_TEST_TASK + 1;
     task.pcName = "it_timeslice_001_f01";

testsuites/kernel/sample/kernel_base/core/task/smp/It_smp_los_task_025.c

@@ -99,7 +99,8 @@ static UINT32 Testcase(void)
     currCpuid = (ArchCurrCpuid() + 1) % LOSCFG_KERNEL_CORE_NUM;
 #endif
 
-    memset(&task, 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s(&task, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     task.pfnTaskEntry = (TSK_ENTRY_FUNC)ItTimeslice002F01;
     task.usTaskPrio = TASK_PRIO_TEST_TASK + 1;
     task.pcName = "it_timeslice_002_f01";

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_001.c

@@ -57,8 +57,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk1";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_002.c

@@ -60,8 +60,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk2";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_003.c

@@ -56,8 +56,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk3";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_004.c

@@ -57,8 +57,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk4";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_006.c

@@ -62,8 +62,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk6";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_007.c

@@ -88,8 +88,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk7";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_008.c

@@ -62,8 +62,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk8";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_009.c

@@ -70,8 +70,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk9";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_010.c

@@ -62,8 +62,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk10";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_011.c

@@ -69,8 +69,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk11";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_012.c

@@ -74,8 +74,8 @@ static UINT32 Testcase(VOID)
 {
     UINT32 ret;
 
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk12";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_013.c

@@ -75,8 +75,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk13";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_014.c

@@ -67,8 +67,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk14";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_015.c

@@ -65,8 +65,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk15";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_016.c

@@ -60,8 +60,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk16";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_018.c

@@ -74,8 +74,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EvtTsk18A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_019.c

@@ -83,8 +83,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EvtTsk19A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_020.c

@@ -84,8 +84,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EvtTsk20A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_021.c

@@ -54,8 +54,8 @@ EXIT:
 static VOID TaskF01(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF02;
     task1.pcName = "EvtTsk21B";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;
@@ -85,8 +85,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EvtTsk21A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_022.c

@@ -73,8 +73,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EvtTsk22A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_023.c

@@ -92,9 +92,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EvtTsk23A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_026.c

@@ -66,8 +66,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk26";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_027.c

@@ -81,8 +81,8 @@ static UINT32 Testcase(VOID)
 
     UINT16 swTmrID;
 
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk27";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_029.c

@@ -55,10 +55,9 @@ static UINT32 Testcase(VOID)
 {
     UINT32 ret;
     UINT32 event;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
     LOS_EventInit(&g_event);
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk29";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_030.c

@@ -52,8 +52,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk30";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_032.c

@@ -83,12 +83,11 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
 
     g_testCount = 0;
     LOS_EventInit(&g_event);
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk32A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_033.c

@@ -96,12 +96,11 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
 
     g_testCount = 0;
     LOS_EventInit(&g_event);
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk33A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_037.c

@@ -60,9 +60,9 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
     LOS_EventInit(&g_event);
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk37";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_038.c

@@ -104,13 +104,12 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
     LOS_EventInit(&g_event);
     LOS_EventInit(&g_pevent2);
 
     g_testCount = 0;
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk38A";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_039.c

@@ -56,10 +56,8 @@ static UINT32 Testcase(VOID)
 {
     UINT32 ret;
     TSK_INIT_PARAM_S task1 = { 0 };
-
     LOS_EventInit(&g_event);
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk39";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_040.c

@@ -55,8 +55,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk40";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_042.c

@@ -56,9 +56,9 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
     EVENT_CB_S pevent = { 0 };
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk42";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_043.c

@@ -81,8 +81,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk43";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/smoke/It_los_event_036.c

@@ -56,11 +56,10 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
+    TSK_INIT_PARAM_S task1 = {0};
 
     LOS_EventInit(&g_event);
 
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk36";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/event/smoke/It_los_event_041.c

@@ -57,8 +57,8 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 ret;
-    TSK_INIT_PARAM_S task1;
-    memset(&task1, 0, sizeof(TSK_INIT_PARAM_S));
+    TSK_INIT_PARAM_S task1 = {0};
+
     task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
     task1.pcName = "EventTsk41";
     task1.uwStackSize = TASK_STACK_SIZE_TEST;

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_057.c

@@ -46,7 +46,8 @@ static UINT32 Testcase(VOID)
 
     g_testQueueID01 = 0;
 
-    memset(bufname, 'a', 5001); // 5001, buffer size.
+    ret = memset_s(bufname, 5001, 'a', 5001); // 5001, buffer size.
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     bufname[5001] = '\0'; // 5001, buffer size.
     ret = LOS_QueueCreate(bufname, 3, &g_testQueueID01, 0, sizeof(UINTPTR)); // 3, Set the queue length.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_087.c

@@ -57,7 +57,8 @@ static UINT32 Testcase(VOID)
         ret = LOS_QueueWrite(g_testQueueID01, filebuf, count, 0);
         ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-        memset(readbuf, 0, 260); // 260, Read buf size.
+        ret = memset_s(readbuf, 260, 0, 260); // 260, Read buf size.
+        ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
         ret = LOS_QueueRead(g_testQueueID01, readbuf, count, 0);
         ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_089.c

@@ -66,7 +66,8 @@ static UINT32 Testcase(VOID)
         ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISFULL, ret, EXIT);
 
         for (i = 0; i < 1000; i++) { // 1000, The loop frequency.
-            memset(readbuf, 0, 260); // 260, Read buf size.
+            ret = memset_s(readbuf, 260, 0, 260); // 260, Read buf size.
+            ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
             ret = LOS_QueueRead(g_testQueueID01, readbuf, QUEUE_SHORT_BUFFER_LENGTH, 0);
             ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
         }

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_098.c

@@ -47,14 +47,16 @@ static UINT32 Testcase(VOID)
     UINT32 readSize;
 
     queueID = LOSCFG_BASE_IPC_QUEUE_CONFIG + 1;
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     readSize = 8; // 8, Read the setting size of queue buffer.
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_INVALID, ret, EXIT);
     ICUNIT_GOTO_EQUAL(readSize, 8, readSize, EXIT); // 8, Here, assert that g_testCount is equal to 8.
 
     queueID = LOSCFG_BASE_IPC_QUEUE_CONFIG;
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
 
     readSize = 8; // 8, Read the setting size of queue buffer.
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
@@ -62,14 +64,16 @@ static UINT32 Testcase(VOID)
     ICUNIT_GOTO_EQUAL(readSize, 8, readSize, EXIT); // 8, Here, assert that g_testCount is equal to 8.
 
     queueID = LOSCFG_BASE_IPC_QUEUE_CONFIG - 1;
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = 8; // 8, Read the setting size of queue buffer.
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_NOT_CREATE, ret, EXIT);
     ICUNIT_GOTO_EQUAL(readSize, 8, readSize, EXIT); // 8, Here, assert that g_testCount is equal to 8.
 
     queueID = 0;
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = 8; // 8, Read the setting size of queue buffer.
     ret = LOS_QueueReadCopy(queueID - 1, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_INVALID, ret, EXIT);

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_099.c

@@ -55,7 +55,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueDelete(queueID);
     ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = 8; // 8, Read the setting size of queue buffer.
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_NOT_CREATE, ret, EXIT);

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_101.c

@@ -52,12 +52,14 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1);
     ret = LOS_QueueReadCopy(queueID, NULL, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_READ_PTR_NULL, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1);
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_102.c

@@ -52,7 +52,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1);
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0xffffffff);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -60,7 +61,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1);
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0xffffffff + 1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -68,7 +70,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1);
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0xffffffff - 1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_106.c

@@ -51,14 +51,16 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWriteCopy(queueID, NULL, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_WRITE_PTR_NULL, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret, EXIT);
 
     ret = LOS_QueueWriteCopy(queueID, &buff1, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 

testsuites/kernel/sample/kernel_base/ipc/queue/full/It_los_queue_107.c

@@ -51,21 +51,24 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWriteCopy(queueID, &buff1, QUEUE_SHORT_BUFFER_LENGTH, 0xffffffff);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
     ret = LOS_QueueWriteCopy(queueID, &buff1, QUEUE_SHORT_BUFFER_LENGTH, 0xffffffff + 1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
     ret = LOS_QueueWriteCopy(queueID, &buff1, QUEUE_SHORT_BUFFER_LENGTH, 0xffffffff - 1);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 

testsuites/kernel/sample/kernel_base/ipc/queue/smoke/It_los_queue_100.c

@@ -51,7 +51,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1);
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -59,7 +60,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1) + 1;
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -67,7 +69,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = sizeof(buff1);
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
@@ -75,7 +78,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWrite(queueID, &buff1, 8, 0); // 8, Write the setting size of queue buffer.
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = 0;
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_READSIZE_IS_INVALID, ret, EXIT);

testsuites/kernel/sample/kernel_base/ipc/queue/smoke/It_los_queue_105.c

@@ -52,32 +52,37 @@ static UINT32 Testcase(VOID)
     ret = LOS_QueueWriteCopy(queueID, &buff1, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
     ret = LOS_QueueWriteCopy(queueID, &buff1, QUEUE_SHORT_BUFFER_LENGTH + PER_ADDED_VALUE, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_WRITE_SIZE_TOO_BIG, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret, EXIT);
 
     ret = LOS_QueueWrite(queueID, &buff1, QUEUE_SHORT_BUFFER_LENGTH - 1, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     ret = LOS_QueueRead(queueID, &buff2, QUEUE_SHORT_BUFFER_LENGTH, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret, EXIT);
 
     ret = LOS_QueueWrite(queueID, &buff1, 0, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    memset(buff2, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ret = memset_s(buff2, QUEUE_SHORT_BUFFER_LENGTH, 0, QUEUE_SHORT_BUFFER_LENGTH);
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     readSize = 0;
     ret = LOS_QueueReadCopy(queueID, &buff2, &readSize, 0);
     ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_READSIZE_IS_INVALID, ret, EXIT);

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_001.c

@@ -71,7 +71,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task01";
@@ -84,7 +85,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_002.c

@@ -63,7 +63,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup002_task01";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_003.c

@@ -94,7 +94,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup003_task01";
@@ -107,7 +108,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup003_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_004.c

@@ -114,7 +114,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup004_task01";
@@ -127,7 +128,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup004_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_005.c

@@ -63,7 +63,8 @@ static void Task01(void)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task03;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup005_task03";
@@ -74,7 +75,8 @@ static void Task01(void)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID03, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT2);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT2;
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task04;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup005_task04";
@@ -137,7 +139,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup005_task01";
@@ -150,7 +153,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup005_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_007.c

@@ -67,7 +67,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup007_task01";
@@ -81,7 +82,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup007_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_008.c

@@ -67,7 +67,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup008_task01";
@@ -80,7 +81,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup008_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_009.c

@@ -50,7 +50,8 @@ static void Task01(void)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task03;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup009_task03";
@@ -90,7 +91,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup009_task01";
@@ -104,7 +106,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup009_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_010.c

@@ -69,7 +69,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task01";
@@ -83,7 +84,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_011.c

@@ -90,7 +90,8 @@ static UINT32 Testcase(VOID)
     TSK_INIT_PARAM_S taskInitParam;
     UINT32 ret;
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task01";
@@ -103,7 +104,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task02";

testsuites/kernel/sample/kernel_extend/cpup/smp/It_smp_extend_cpup_012.c

@@ -73,7 +73,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_EventInit(&g_eventCB);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT0);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT0);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task01;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task01";
@@ -86,7 +87,8 @@ static UINT32 Testcase(VOID)
     ret = LOS_TaskCreate(&g_testSmpCpupTaskID01, &taskInitParam);
     ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
 
-    (VOID)memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ret = memset_s((void *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT1);
     taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)Task02;
     taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
     taskInitParam.pcName = "SmpCpup001_task02";

testsuites/kernel/src/iCunit.c

@@ -194,7 +194,7 @@ iUINT32 ICunitInit(void)
     g_iCunitCaseCnt = 0x0000;
     g_iCunitCaseFailedCnt = 0;
     g_iCunitErrLogAddCase = 0;
-    memset(g_iCunitCaseArray, 0, sizeof(g_iCunitCaseArray));
+    (void)memset_s(g_iCunitCaseArray, sizeof(g_iCunitCaseArray), 0, sizeof(g_iCunitCaseArray));
     g_iCunitCaseRun = 1;
 
     return (iUINT32)ICUNIT_SUCCESS;
@@ -233,12 +233,12 @@ iUINT32 ICunitRunF(ICUNIT_CASE_S *psubCase)
     static LosSemCB *semNode;
     UINT32 muxCnt[ARRAY_SIZE];
 
-    memset(gUwSwtNum, 0, sizeof(gUwSwtNum));
-    memset(gUwHwiNum, 0, sizeof(gUwHwiNum));
-    memset(gUwTskNum, 0, sizeof(gUwTskNum));
-    memset(gAuwMemuse, 0, sizeof(gAuwMemuse));
-    memset(gUwQueueNum, 0, sizeof(gUwQueueNum));
-    memset(gUwSemNum, 0, sizeof(gUwSemNum));
+    (void)memset_s(gUwSwtNum, sizeof(gUwSwtNum), 0, sizeof(gUwSwtNum));
+    (void)memset_s(gUwHwiNum, sizeof(gUwHwiNum), 0, sizeof(gUwHwiNum));
+    (void)memset_s(gUwTskNum, sizeof(gUwTskNum), 0, sizeof(gUwTskNum));
+    (void)memset_s(gAuwMemuse, sizeof(gAuwMemuse), 0, sizeof(gAuwMemuse));
+    (void)memset_s(gUwQueueNum, sizeof(gUwQueueNum), 0, sizeof(gUwQueueNum));
+    (void)memset_s(gUwSemNum, sizeof(gUwSemNum), 0, sizeof(gUwSemNum));
 
     curTestTaskID = LOS_CurTaskIDGet();
 
@@ -577,7 +577,7 @@ iUINT32 ICunitRunTestArrayRandom(iUINT32 testcaseNum, iUINT32 testcaseLayer, iUI
     iUINT32 failedCount;
     iUINT32 successCount;
 
-    memset(&subCaseArrayTemp, 0, sizeof(ICUNIT_CASE_S));
+    (void)memset_s(&subCaseArrayTemp, sizeof(ICUNIT_CASE_S), 0, sizeof(ICUNIT_CASE_S));
 
     idx1 = g_iCunitCaseCnt;
 
@@ -586,7 +586,7 @@ iUINT32 ICunitRunTestArrayRandom(iUINT32 testcaseNum, iUINT32 testcaseLayer, iUI
         successCount = g_passResult;
 
         for (idx = idx1 - 1; idx > 1; idx--) {
-            memset(&subCaseArrayTemp, 0, sizeof(ICUNIT_CASE_S));
+            (void)memset_s(&subCaseArrayTemp, sizeof(ICUNIT_CASE_S), 0, sizeof(ICUNIT_CASE_S));
 
             randIdx = ICunitRand() % idx;
             subCaseArrayTemp = g_iCunitCaseArray[randIdx];
@@ -611,12 +611,12 @@ iUINT32 ICunitRunTestOne(const char *tcId)
     iUINT32 idx1;
     ICUNIT_CASE_S subCaseArrayTemp;
 
-    memset(&subCaseArrayTemp, 0, sizeof(ICUNIT_CASE_S));
+    (void)memset_s(&subCaseArrayTemp, sizeof(ICUNIT_CASE_S), 0, sizeof(ICUNIT_CASE_S));
 
     idx1 = g_iCunitCaseCnt;
 
     for (idx = 0; idx < idx1; idx++) {
-        memset(&subCaseArrayTemp, 0, sizeof(ICUNIT_CASE_S));
+        (void)memset_s(&subCaseArrayTemp, sizeof(ICUNIT_CASE_S), 0, sizeof(ICUNIT_CASE_S));
         subCaseArrayTemp = g_iCunitCaseArray[idx];
 
         if (strcmp(subCaseArrayTemp.pcCaseID, tcId) == 0) {

testsuites/unittest/drivers/hid/smoke/hid_test_001.cpp

@@ -55,7 +55,8 @@ static int Testcase(VOID)
 
         buf = (char *)malloc(MOUSE_DATA_LEN);
         ICUNIT_ASSERT_NOT_EQUAL(buf, NULL, buf);
-        (void)memset_s(buf, MOUSE_DATA_LEN, 0, MOUSE_DATA_LEN);
+        ret = memset_s(buf, MOUSE_DATA_LEN, 0, MOUSE_DATA_LEN);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
         ret = ioctl(fd, USB_GET_REPORT_ID, &id);
         ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);

testsuites/unittest/drivers/storage/smoke/storage_test_001.cpp

@@ -53,7 +53,8 @@ static int Testcase(VOID)
 
         buf = (char *)malloc(STORAGE_DATA_LEN);
         ICUNIT_ASSERT_NOT_EQUAL(buf, NULL, buf);
-        (void)memset_s(buf, STORAGE_DATA_LEN, 0, STORAGE_DATA_LEN);
+        ret = memset_s(buf, STORAGE_DATA_LEN, 0, STORAGE_DATA_LEN);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
         ret = ioctl(fd, DIOC_GETPRIV, &bch);
         printf("bch = %#x, &bch = %#x, errno = %d\n", bch, &bch, errno);

testsuites/unittest/extended/liteipc/smgr_demo.cpp

@@ -48,7 +48,7 @@ BOOL g_cmsRunningFlag = FALSE;
 
 static void InitCms()
 {
-    memset(g_serviceNameMap, 0, sizeof(g_serviceNameMap));
+    (void)memset_s(g_serviceNameMap, sizeof(g_serviceNameMap), 0, sizeof(g_serviceNameMap));
 }
 
 uint32_t SetCms(int fd)
@@ -66,7 +66,7 @@ void SendReply(int fd, IpcMsg *dataIn, uint32_t result, uint32_t serviceHandle)
     data1.flag = SEND | BUFF_FREE;
     data1.buffToFree = dataIn;
     data1.outMsg = &dataOut;
-    memset(data1.outMsg, 0, sizeof(IpcMsg));
+    (void)memset_s(data1.outMsg, sizeof(IpcMsg), 0, sizeof(IpcMsg));
     data1.outMsg->type = MT_REPLY;
     data1.outMsg->target.handle = dataIn->taskID;
     data1.outMsg->target.token = dataIn->target.token;
@@ -118,12 +118,12 @@ uint32_t RegService(int fd, char *serviceName, uint32_t nameLen, uint32_t *servi
     if (nameLen > NAME_LEN_MAX) {
         return -1;
     }
-    memcpy(name.serviceName, serviceName, nameLen);
+    (void)memcpy_s(name.serviceName, nameLen, serviceName, nameLen);
     name.nameLen = nameLen;
 
     data1.flag = SEND | RECV;
     data1.outMsg = &dataOut;
-    memset(data1.outMsg, 0, sizeof(IpcMsg));
+    (void)memset_s(data1.outMsg, sizeof(IpcMsg), 0, sizeof(IpcMsg));
     data1.outMsg->type = MT_REQUEST;
     data1.outMsg->target.handle = 0;
     data1.outMsg->code = REG_CODE;
@@ -153,12 +153,12 @@ uint32_t GetService(int fd, char *serviceName, uint32_t nameLen, uint32_t *servi
     if (nameLen > NAME_LEN_MAX) {
         return -1;
     }
-    memcpy(name.serviceName, serviceName, nameLen);
+    (void)memcpy_s(name.serviceName, nameLen, serviceName, nameLen);
     name.nameLen = nameLen;
 
     data1.flag = SEND | RECV;
     data1.outMsg = &dataOut;
-    memset(data1.outMsg, 0, sizeof(IpcMsg));
+    (void)memset_s(data1.outMsg, sizeof(IpcMsg), 0, sizeof(IpcMsg));
     data1.outMsg->type = MT_REQUEST;
     data1.outMsg->target.handle = 0;
     data1.outMsg->code = GET_CODE;
@@ -210,7 +210,8 @@ static void HandleServiceRegAndGet(int fd, IpcMsg *data)
                     printf("the task has already a service named:%s\n", g_serviceNameMap[content.serviceHandle].serviceName);
                     goto ERROR_REG;
                 } else {
-                    (void)memcpy_s(g_serviceNameMap[content.serviceHandle].serviceName, info->nameLen, info->serviceName, info->nameLen);
+                    (void)memcpy_s(g_serviceNameMap[content.serviceHandle].serviceName, info->nameLen,
+                                   info->serviceName, info->nameLen);
                     g_serviceNameMap[content.serviceHandle].nameLen = info->nameLen;
                     SendReply(fd, data, 0, content.serviceHandle);
                 }
@@ -281,7 +282,7 @@ void StopCms(int fd)
 
     data1.flag = SEND;
     data1.outMsg = &dataOut;
-    memset(data1.outMsg, 0, sizeof(IpcMsg));
+    (void)memset_s(data1.outMsg, sizeof(IpcMsg), 0, sizeof(IpcMsg));
     data1.outMsg->type = MT_REQUEST;
     data1.outMsg->target.handle = 0;
     data1.outMsg->code = STOP_CODE;

testsuites/unittest/extended/liteipc/smoke/liteipc_test_002.cpp

@@ -78,7 +78,7 @@ static int CallTestServiceLoop(uint32_t id)
 #endif
         data1.flag = SEND | RECV;
         data1.outMsg = &dataOut;
-        memset(data1.outMsg, 0, sizeof(IpcMsg));
+        (void)memset_s(data1.outMsg, sizeof(IpcMsg), 0, sizeof(IpcMsg));
         data1.outMsg->type = MT_REQUEST;
         data1.outMsg->target.handle = serviceHandle;
         data1.outMsg->dataSz = 4;
@@ -98,7 +98,7 @@ static int CallTestServiceLoop(uint32_t id)
     char tmpBuff[2048];
     data1.flag = SEND | RECV;
     data1.outMsg = &dataOut;
-    memset(data1.outMsg, 0, sizeof(IpcMsg));
+    (void)memset_s(data1.outMsg, sizeof(IpcMsg), 0, sizeof(IpcMsg));
     data1.outMsg->type = MT_REQUEST;
     data1.outMsg->target.handle = serviceHandle;
     data1.outMsg->dataSz = 1024;

testsuites/unittest/extended/signal/full/It_ipc_pipe_002.cpp

@@ -37,7 +37,7 @@ static UINT32 Testcase(VOID)
     char buffer[20];          // 20, target buffer size
     int *sharedflag = NULL;
     int shmid;
-    
+
     ret = pipe(pipeFd);
     ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT1);
     shmid = shmget((key_t)IPC_PRIVATE, sizeof(int), 0666 | IPC_CREAT); // 0666 the authority of the shm

testsuites/unittest/extended/signal/full/pipe_test_001.cpp

@@ -59,12 +59,12 @@ int TestPipeSingleProcess()
             char sentence1[15] = "Hello World";
             char a[4] = {0};
             (void)sprintf_s(a, sizeof(a), "%d", i);
-            strcat(sentence1, a);
+            (void)strcat_s(sentence1, 15, a); // 15, sizeof sentence1
             int ret = write(*writeFd, sentence1, strlen(sentence1) + 1);
             usleep(100000); // 100000, Used to calculate the delay time.
 
             printf("read\n");
-            memset(readbuffer, 0, sizeof(readbuffer));
+            (void)memset_s(readbuffer, sizeof(readbuffer), 0, sizeof(readbuffer));
             retValue = read(*readFd, readbuffer, sizeof(readbuffer));
             printf("Receive %d bytes data : %s,%d\n", retValue, readbuffer, errno);
             if (strncmp((readbuffer), (readbuffer), (strlen(sentence1))) != 0) {

testsuites/unittest/extended/signal/full/pipe_test_003.cpp

@@ -59,7 +59,7 @@ int TestPipeSingleProcessFcntl()
             char sentence1[15] = "Hello World";
             char a[4] = {0};
             (void)sprintf_s(a, sizeof(a), "%d", i);
-            strcat(sentence1, a);
+            (void)strcat_s(sentence1, 15, a); // 15, sizeof sentence1
             int ret = write(*writeFd, sentence1, strlen(sentence1) + 1);
             usleep(100000); // 100000, Used to calculate the delay time.
         }
@@ -67,7 +67,7 @@ int TestPipeSingleProcessFcntl()
         char a[4] = {0};
         usleep(10000); // 10000, Used to calculate the delay time.
         printf("read\n");
-        memset(readbuffer, 0, sizeof(readbuffer));
+        (void)memset_s(readbuffer, sizeof(readbuffer), 0, sizeof(readbuffer));
         retValue = read(*readFd, readbuffer, sizeof(readbuffer));
         printf("Receive %d bytes data : %s,%d\n", retValue, readbuffer, errno);
         printf("Receive %d bytes data : %s,%d\n", retValue, readbuffer + 13, errno); // 13, readbuffer offset.
@@ -78,7 +78,7 @@ int TestPipeSingleProcessFcntl()
         usleep(100000); // 100000, Used to calculate the delay time.
 
         printf("read\n");
-        memset(readbuffer, 0, sizeof(readbuffer));
+        (void)memset_s(readbuffer, sizeof(readbuffer), 0, sizeof(readbuffer));
         fcntl(*readFd, F_SETFL, O_NONBLOCK);
         ret = fcntl(*readFd, F_GETFL, O_NONBLOCK);
         printf("fctrl ret=%d,O_NONBLOCK=%d\n", ret, O_NONBLOCK);

testsuites/unittest/extended/signal/full/pipe_test_006.cpp

@@ -31,6 +31,8 @@
 #include "it_test_signal.h"
 #include "signal.h"
 
+static const int NAME_LEN  = 60;
+
 static const int MAX_PIPES = 32;
 
 static int PipeUnlinkTest()
@@ -41,7 +43,7 @@ static int PipeUnlinkTest()
     int retValue = -1;
 
     int status, ret;
-    char devName[60]; // 60, array subscript
+    char devName[NAME_LEN]; // 60, array subscript
     pid = fork();
     if (pid == -1) {
         printf("Fork Error!\n");
@@ -54,7 +56,7 @@ static int PipeUnlinkTest()
         retValue = pipe(tmpFd);
         ICUNIT_ASSERT_EQUAL_EXIT(retValue, -1, __LINE__);
         for (int i = 0; i < MAX_PIPES; i++) {
-            snprintf(devName, 60, "/dev/pipe%d", i); // 60, len of max size
+            (void)snprintf_s(devName, NAME_LEN, NAME_LEN - 1, "/dev/pipe%d", i); // 60, len of max size
             retValue = unlink(devName);
             ICUNIT_ASSERT_EQUAL_EXIT(retValue, -1, __LINE__);
             retValue = close(pipefd[i][0]);

testsuites/unittest/extended/signal/smoke/pipe_test_002.cpp

@@ -68,7 +68,7 @@ static int TestPipeMultiProcess()
             char sentence1[15] = "Hello World";
             char a[2] = {0};
             (void)sprintf_s(a, sizeof(a), "%d", i);
-            strcat(sentence1, a);
+            (void)strcat_s(sentence1, 15, a); // 15, sizeof sentence1
             int ret = write(*writeFd, sentence1, strlen(sentence1) + 1);
             ICUNIT_ASSERT_EQUAL(ret, strlen(sentence1) + 1, ret);
             usleep(10000); // 10000, Used to calculate the delay time.
@@ -88,8 +88,8 @@ static int TestPipeMultiProcess()
             char sentence1[15] = "Hello World";
             char a[2] = {0};
             (void)sprintf_s(a, sizeof(a), "%d", i);
-            strcat(sentence1, a);
-            memset(readbuffer, 0, sizeof(readbuffer));
+            (void)strcat_s(sentence1, 15, a); // 15, sizeof sentence1
+            (void)memset_s(readbuffer, sizeof(readbuffer), 0, sizeof(readbuffer));
             retValue = read(*readFd, readbuffer, strlen(sentence1) + 1);
             printf("Receive %d bytes data : %s, errno : %d\n", retValue, readbuffer, errno);
             ICUNIT_ASSERT_SIZE_STRING_EQUAL(readbuffer, sentence1, strlen(sentence1), errno);

testsuites/unittest/libc/io/full/IO_test_epoll_001.cpp

@@ -51,6 +51,7 @@ static UINT32 testcase(VOID)
     sigset_t mask;
     struct epoll_event ev;
     struct epoll_event evWait[2]; /* 2, evs num */
+    UINT32 ret;
 
     retval = pipe(pipeFd);
     ICUNIT_GOTO_EQUAL(retval, 0, retval, OUT);
@@ -71,7 +72,8 @@ static UINT32 testcase(VOID)
     if (pid == 0) {
         close(pipeFd[1]);
 
-        memset(evWait, 0, sizeof(struct epoll_event) * 2); /* 2, evs num */
+        ret = memset_s(evWait, sizeof(struct epoll_event) * 2, 0, sizeof(struct epoll_event) * 2); /* 2, evs num */
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
         retval = epoll_wait(epFd, evWait, 2, 3000); /* 2, num of wait fd. 3000, wait time */
         close(pipeFd[0]);
 

testsuites/unittest/libc/io/full/IO_test_epoll_002.cpp

@@ -97,7 +97,7 @@ static UINT32 testcase(VOID)
     if (pid == 0) {
         close(pipeFd[1]);
 
-        memset(evWait, 0, sizeof(struct epoll_event) * 2); /* 2, evs num */
+        (void)memset_s(evWait, sizeof(struct epoll_event) * 2, 0, sizeof(struct epoll_event) * 2); /* 2, evs num */
         evWait[0].data.fd = pipeFd[0];
 
         retval = epoll_pwait(epFd, evWait, 2, 3000, &mask); /* 2, num of wait fd. 3000, wait time */

testsuites/unittest/libc/io/full/It_stdio_fputws_001.cpp

@@ -40,9 +40,13 @@ static UINT32 Testcase(VOID)
     int nType;
     char pathname[50]; // 50, path name buffer size
     FILE *testFile;
-    (void)strncpy_s(pathname, 50, g_ioTestPath, 50); // 50, path name buffer size
+    int ret;
+
+    ret = strncpy_s(pathname, 50, g_ioTestPath, 50); // 50, path name buffer size
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     char *filename = "/crtfputwstest1";
-    strcat(pathname, filename);
+    ret = strcat_s(pathname, 50, filename); // 50, path name buffer size
+    ICUNIT_ASSERT_EQUAL(ret, EOK, ret);
     for (nType = 0; nType < 6; nType++) { // 6, test loop num
         testFile = fopen(pathname, "a");
 

testsuites/unittest/libc/io/full/It_stdio_fwprintf_001.cpp

@@ -38,12 +38,14 @@ static UINT32 Testcase(VOID)
     int nRet;
     unsigned int nPos;
     int nType;
-    char pathname[50];                   // 50, path name buffer size
-    strncpy(pathname, g_ioTestPath, 50); // 50, path name buffer size
+    char pathname[50];  // 50, path name buffer size
+    (void)strncpy_s(pathname, 50, g_ioTestPath, 50); // 50, path name buffer size
     char *filename = "/crtfwprintftest1";
     FILE *testFile = NULL;
+    int ret;
 
-    strcat(pathname, filename);
+    ret = strcat_s(pathname, 50, filename); // 50, path name buffer size
+    ICUNIT_ASSERT_EQUAL(ret, EOK, ret);
 
     for (nType = 0; nType < 6; nType++) { // 6, loop test num
         testFile = fopen(pathname, "w+");
@@ -52,7 +54,7 @@ static UINT32 Testcase(VOID)
         nPos = (unsigned int)ftell(testFile);
 
         nRet = fwprintf(testFile, L"hello world %d", 666); // 666, for test, print to testFile
-        ICUNIT_GOTO_EQUAL(nRet, 15, nRet, EXIT);           // 15， total write size
+        ICUNIT_GOTO_EQUAL(nRet, 15, nRet, EXIT);  // 15， total write size
 
         if ((nPos + 15) != (unsigned int)ftell(testFile)) { // 15， total write size
             ICUNIT_GOTO_EQUAL(1, 0, 1, EXIT);

testsuites/unittest/libc/io/full/It_stdio_getc_unlocked_001.cpp

@@ -37,11 +37,15 @@ static UINT32 Testcase(VOID)
     unsigned int nPos;
     int ret;
     char pathname[50]; // 50, enough space.
-    (void)strncpy_s(pathname, sizeof(pathname), g_ioTestPath, sizeof(pathname));
     char *filename = "/crt_getc_unlocked_test1";
     FILE *testFile = NULL;
 
-    strcat(pathname, filename);
+    ret = strncpy_s(pathname, sizeof(pathname), g_ioTestPath, sizeof(pathname));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = strcat_s(pathname, 50, filename); // 50, path name buffer size
+    ICUNIT_ASSERT_EQUAL(ret, EOK, ret);
+
     testFile = fopen(pathname, "w+");
     ICUNIT_ASSERT_NOT_EQUAL(testFile, NULL, LOS_NOK);
     ret = fputs("0123456789abcdefghijklmnopqrstuvwxyz", testFile);

testsuites/unittest/libc/io/full/It_stdio_mbrlen_001.cpp

@@ -38,9 +38,11 @@ static UINT32 Testcase(VOID)
     const char *str = "水";
     size_t sz = strlen(str);
     int len1, len2, len3;
+    UINT32 ret;
 
     mbstate_t mb;
-    memset(&mb, 0, sizeof(mb));
+    ret = memset_s(&mb, sizeof(mb), 0, sizeof(mb));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     len1 = mbrlen(str, 1, &mb);
     ICUNIT_GOTO_EQUAL(len1, -2, len1, EXIT); // -2, except return value
 

testsuites/unittest/libc/io/full/It_stdio_putwc_001.cpp

@@ -38,11 +38,15 @@ static UINT32 Testcase(VOID)
     long nPos;
     int nType, i;
     FILE *putwcFile = NULL;
-    char pathname[50];                   // 50, pathname size
-    strncpy(pathname, g_ioTestPath, 50); // 50, pathname size
+    char pathname[50]; // 50, pathname size
     char *filename = "/crtputwctest1";
+    int ret;
 
-    strcat(pathname, filename);
+    ret = strncpy_s(pathname, 50, g_ioTestPath, 50); // 50, pathname size
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = strcat_s(pathname, 50, filename); // 50, path name buffer size
+    ICUNIT_ASSERT_EQUAL(ret, EOK, ret);
 
     for (nType = 0; nType < 6; nType++) { // 6, loop test num
         putwcFile = fopen(pathname, "w+");

testsuites/unittest/libc/io/full/It_stdio_readv_001.cpp

@@ -41,14 +41,16 @@ static UINT32 Testcase(VOID)
     struct iovec iov[2]; // 2, read 2 block
     ssize_t nread;
     const int testStrLen = 10;
+    UINT32 ret;
 
     iov[0].iov_base = buf1;
     iov[0].iov_len = sizeof(buf1) - 1;
     iov[1].iov_base = buf2;
     iov[1].iov_len = sizeof(buf2) - 1;
 
-    strncpy(pathname, g_ioTestPath, 50); // 50, path name size
-    strcat(pathname, filename);
+    (void)strncpy_s(pathname, 50, g_ioTestPath, 50); // 50, path name size
+    ret = strcat_s(pathname, 50, filename); // 50, path name buffer size
+    ICUNIT_ASSERT_EQUAL(ret, EOK, ret);
     fd = open(pathname, O_CREAT | O_RDWR | O_TRUNC, 0666); // 0666, file authority
     if (fd < 0) {
         printf("error: can`t open file\n");

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_002.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 1;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq002_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq002_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -66,6 +68,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_005.cpp

@@ -32,10 +32,13 @@
 
 static UINT32 Testcase(VOID)
 {
+    INT32 ret;
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq005_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq005_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     mqueue = mq_open(mqname, O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT);
     ICUNIT_ASSERT_EQUAL(errno, ENOENT, errno);
@@ -45,6 +48,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqueue);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_008.cpp

@@ -36,8 +36,10 @@ static UINT32 Testcase(VOID)
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     mqd_t roqueue, roqueue2;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq008_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq008_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     roqueue = mq_open(mqname, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(roqueue, (mqd_t)-1, roqueue, EXIT);
 
@@ -59,6 +61,7 @@ EXIT1:
 EXIT:
     mq_close(roqueue);
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_011.cpp

@@ -40,8 +40,10 @@ static UINT32 Testcase(VOID)
     mqd_t rdwrqueue, rdwrqueue2;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq011_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq011_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
     rdwrqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
@@ -77,6 +79,7 @@ EXIT1:
 EXIT:
     mq_close(rdwrqueue);
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_013.cpp

@@ -37,8 +37,10 @@ static UINT32 Testcase(VOID)
     const CHAR *msgptr = MQUEUE_SEND_STRING_TEST;
     mqd_t mqueue1, mqueue2;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq013_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq013_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
+    
     mqueue1 = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue1, (mqd_t)-1, mqueue1, EXIT1);
 
@@ -67,6 +69,7 @@ EXIT1:
     mq_close(mqueue1);
 EXIT:
     mq_unlink(mqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_014.cpp

@@ -37,7 +37,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq014_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq014_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -60,6 +62,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_015.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr = { 0 };
     struct mq_attr attrget;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq015_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq015_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
     attr.mq_msgsize = 5; // 5, queue message size.
@@ -67,6 +69,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_016.cpp

@@ -36,8 +36,10 @@ static UINT32 Testcase(VOID)
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     mqd_t mqueue1, mqueue2;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq016_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq016_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
+    
     mqueue1 = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue1, (mqd_t)-1, mqueue1, EXIT1);
 
@@ -57,6 +59,7 @@ EXIT1:
     mq_close(mqueue1);
 EXIT:
     mq_unlink(mqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_018.cpp

@@ -37,7 +37,9 @@ static UINT32 Testcase(VOID)
     const CHAR *msgptr = MQUEUE_SEND_STRING_TEST;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq018_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq018_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -56,6 +58,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_019.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue1, mqueue2;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq019_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq019_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -76,6 +78,7 @@ EXIT1:
     mq_close(mqueue1);
 EXIT:
     mq_unlink(mqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_020.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     struct sigevent ev;
     struct sigaction act;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq020_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq020_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -54,6 +56,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_021.cpp

@@ -32,10 +32,13 @@
 
 static UINT32 Testcase(VOID)
 {
+    INT32 ret;
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq021_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq021_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     mqueue = mq_open(mqname, O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT);
@@ -45,6 +48,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqueue);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_025.cpp

@@ -30,16 +30,23 @@
  */
 #include "It_posix_queue.h"
 
+#define QUEUE_NAME_MAX_LEN (MQUEUE_NAME_MAX_TEST * 2)
+
 static UINT32 Testcase(VOID)
 {
-    CHAR mqname[MQUEUE_NAME_MAX_TEST * 2];
+    CHAR mqname[QUEUE_NAME_MAX_LEN];
     mqd_t mqueue;
+    UINT32 ret;
     INT32 i;
 
-    snprintf(mqname, MQUEUE_NAME_MAX_TEST * 2, "/mq025_%d", LosCurTaskIDGet()); // 2, mqname length.
+    ret = snprintf_s(mqname, QUEUE_NAME_MAX_LEN, QUEUE_NAME_MAX_LEN - 1, \
+                     "/mq025_%d", LosCurTaskIDGet()); // 2, mqname length.
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
-    for (i = 0; i < MQUEUE_NAME_MAX_TEST; i++)
-        strcat(mqname, "0");
+    for (i = 0; i < MQUEUE_NAME_MAX_TEST; i++) {
+        ret = strcat_s(mqname, QUEUE_NAME_MAX_LEN, "0");
+        ICUNIT_ASSERT_EQUAL(ret, EOK, ret);
+    }
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT);
@@ -49,6 +56,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqueue);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_026.cpp

@@ -32,10 +32,13 @@
 
 static UINT32 Testcase(VOID)
 {
+    INT32 ret;
     CHAR qname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     mqd_t queue;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq026-1_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq026-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     queue = mq_open(qname, O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_EQUAL(queue, (mqd_t)-1, queue, EXIT);
@@ -45,6 +48,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(queue);
     mq_unlink(qname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_027.cpp

@@ -36,7 +36,9 @@ static UINT32 Testcase(VOID)
     INT32 ret;
     mqd_t queue;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq027-1_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq027-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     queue = mq_open(qname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     if (queue == (mqd_t)-1) {
@@ -53,6 +55,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(queue);
     mq_unlink(qname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_031.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq031_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq031_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -69,6 +71,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_032.cpp

@@ -37,7 +37,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct sigevent se;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq032_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq032_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -53,6 +55,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_033.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq033_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq033_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -66,6 +68,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_036.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq036_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq036_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -60,6 +62,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_038.cpp

@@ -37,8 +37,10 @@ static UINT32 Testcase(VOID)
     const CHAR *msgptr = MQUEUE_SEND_STRING_TEST;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq038_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq038_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
@@ -57,6 +59,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_040.cpp

@@ -88,7 +88,9 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr = { 0 };
     pthread_attr_t attr1;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq040_%d", getpid());
+    ret = snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq040_%d", getpid());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 5; // 5, queue max message size.
@@ -133,6 +135,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(g_gqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_041.cpp

@@ -91,7 +91,9 @@ static UINT32 Testcase(VOID)
     pthread_attr_t attr1;
     pthread_t newTh1, newTh2;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq041_%d", LosCurTaskIDGet());
+    ret = snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq041_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 5; // 5, queue max message size.
@@ -135,6 +137,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(g_gqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_042.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq042_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq042_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -48,7 +50,8 @@ static UINT32 Testcase(VOID)
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
     while (1) {
-        snprintf(msgptr, MQUEUE_STANDARD_NAME_LENGTH, "message %d", i);
+        ret = snprintf_s(msgptr, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, "message %d", i);
+        ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
         ret = mq_send(mqueue, msgptr, strlen(msgptr), 0);
         if (ret == -1) {
             ICUNIT_GOTO_EQUAL(errno, EAGAIN, errno, EXIT1);
@@ -59,7 +62,8 @@ static UINT32 Testcase(VOID)
     ICUNIT_GOTO_EQUAL(i, MQUEUE_SHORT_ARRAY_LENGTH, i, EXIT1);
 
     i = 0;
-    snprintf(msgptr, MQUEUE_STANDARD_NAME_LENGTH, "message %d", i);
+    ret = snprintf_s(msgptr, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, "message %d", i);
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     ret = mq_receive(mqueue, msgrcd, MQUEUE_STANDARD_NAME_LENGTH, NULL);
     ICUNIT_GOTO_EQUAL(ret, strlen(msgptr), ret, EXIT1);
 
@@ -77,6 +81,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_043.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq043_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq043_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -67,6 +69,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_044.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq044_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq044_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -68,6 +70,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_046.cpp

@@ -37,7 +37,9 @@ static UINT32 Testcase(VOID)
     mqd_t queue;
     INT32 unresolved = 0, failure = 0, ret = 0;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq046-1_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq046-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
 
     queue = mq_open(qname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(queue, (mqd_t)-1, queue, EXIT);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_047.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     const CHAR *msgptr = MQUEUE_SEND_STRING_TEST;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq047_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq047_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -66,6 +68,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_048.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq048_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq048_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -67,6 +69,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_049.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     const CHAR *msgptr = MQUEUE_SEND_STRING_TEST;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq049_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq049_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -60,6 +62,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_050.cpp

@@ -40,8 +40,10 @@ static UINT32 Testcase(VOID)
 
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq050_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq050_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     for (i = 0; i < MQUEUE_PRIORITY_NUM_TEST; i++) {
         attr.mq_msgsize = messagesize[i];
         attr.mq_maxmsg = messagesize[i];
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_052.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq052_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq052_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH + 1;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH + 1;
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_054.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq054_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq054_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -60,6 +62,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_055.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq055_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq055_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -80,6 +82,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_056.cpp

@@ -37,7 +37,9 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr = { 0 };
     INT32 unresolved = 0, failure = 0, ret = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq056-1-%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq056-1-%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -63,6 +65,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqdes);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_057.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     CHAR msgrv[MQUEUE_STANDARD_NAME_LENGTH] = {0};
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq057_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq057_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -61,6 +63,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_058.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr = { 0 };
     INT32 unresolved = 0, failure = 0, ret = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq058-2-%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq058-2-%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -59,6 +61,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqdes);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_060.cpp

@@ -35,8 +35,10 @@ static UINT32 Testcase(VOID)
     INT32 ret;
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq060_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq060_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
+    
     ret = mq_unlink(mqname);
     ICUNIT_GOTO_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     ICUNIT_GOTO_EQUAL(errno, ENOENT, errno, EXIT);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_061.cpp

@@ -38,12 +38,15 @@ static UINT32 Testcase(VOID)
     INT32 unresolved = 0;
     INT32 failure = 0, ret = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq061-1_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq061-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
+    
     mqdes = mq_open(mqname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqdes, (mqd_t)-1, mqdes, EXIT);
 
-    memset(&mqstat, 0, sizeof(mqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
 
     ret = mq_getattr(mqdes, &mqstat);
     ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
@@ -63,6 +66,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqdes);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_063.cpp

@@ -38,15 +38,19 @@ static UINT32 Testcase(VOID)
     INT32 unresolved = 0;
     INT32 failure = 0, ret = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq063-1_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq063-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
-    memset(&mqstat, 0, sizeof(mqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     mqstat.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     mqstat.mq_maxmsg = 40; // 40, queue max message size.
     mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &mqstat);
     ICUNIT_GOTO_NOT_EQUAL(mqdes, (mqd_t)-1, mqdes, EXIT);
 
-    memset(&nmqstat, 0, sizeof(nmqstat));
+    ret = memset_s(&nmqstat, sizeof(nmqstat), 0, sizeof(nmqstat));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
 
     ret = mq_getattr(mqdes, &nmqstat);
     ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
@@ -66,6 +70,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqdes);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_064.cpp

@@ -38,9 +38,12 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr mqstat;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq064_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq064_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
-    memset(&mqstat, 0, sizeof(mqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     mqstat.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     mqstat.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &mqstat);
@@ -50,7 +53,8 @@ static UINT32 Testcase(VOID)
         ret = mq_send(mqueue, msgptr, strlen(msgptr), 0);
         ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     }
-    memset(&mqstat, 0, sizeof(mqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT1);
     ret = mq_getattr(mqueue, &mqstat);
     ICUNIT_GOTO_EQUAL(ret, MQUEUE_NO_ERROR, ret, EXIT1);
     ICUNIT_GOTO_EQUAL(mqstat.mq_curmsgs, 5, mqstat.mq_curmsgs, EXIT1); // 5, assert the curmsgs.
@@ -66,6 +70,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_065.cpp

@@ -37,13 +37,16 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue, mqdesInvalid;
     struct mq_attr mqstat;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq065_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq065_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
     mqdesInvalid = (mqd_t)((UINTPTR)mqueue + PER_ADDED_VALUE);
-    memset(&mqstat, 0, sizeof(mqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT1);
 
     ret = mq_getattr(mqdesInvalid, &mqstat);
     ICUNIT_GOTO_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
@@ -60,6 +63,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_066.cpp

@@ -39,13 +39,17 @@ static UINT32 Testcase(VOID)
     INT32 unresolved = 0;
     INT32 failure = 0, ret = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq066-1_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq066-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
+    
     mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
     ICUNIT_GOTO_NOT_EQUAL(mqdes, (mqd_t)-1, mqdes, EXIT);
 
-    memset(&mqstat, 0, sizeof(mqstat));
-    memset(&nmqstat, 0, sizeof(nmqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
+    ret = memset_s(&nmqstat, sizeof(nmqstat), 0, sizeof(nmqstat));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
     ret = mq_getattr(mqdes, &mqstat);
     ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT);
@@ -73,6 +77,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqdes);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_067.cpp

@@ -38,13 +38,17 @@ static UINT32 Testcase(VOID)
     struct mq_attr mqstat1 = { 0 };
     struct mq_attr mqstat2 = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq067_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq067_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
-    memset(&mqstat1, 0, sizeof(mqstat1));
-    memset(&mqstat2, 0, sizeof(mqstat1));
+    ret = memset_s(&mqstat1, sizeof(mqstat1), 0, sizeof(mqstat1));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
+    ret = memset_s(&mqstat2, sizeof(mqstat2), 0, sizeof(mqstat1));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
 
     ret = mq_getattr(mqueue, &mqstat1);
     ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT1);
@@ -73,6 +77,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_069.cpp

@@ -38,16 +38,20 @@ static UINT32 Testcase(VOID)
     struct mq_attr mqstat1;
     struct mq_attr mqstat2;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq069_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq069_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
+    
     mqueue1 = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
     ICUNIT_GOTO_NOT_EQUAL(mqueue1, (mqd_t)-1, mqueue1, EXIT1);
 
     mqueue2 = mqueue1;
     mqueue1 = (mqd_t)((UINTPTR)mqueue1 + PER_ADDED_VALUE);
 
-    memset(&mqstat1, 0, sizeof(mqstat1));
-    memset(&mqstat2, 0, sizeof(mqstat2));
+    ret = memset_s(&mqstat1, sizeof(mqstat1), 0, sizeof(mqstat1));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
+    ret = memset_s(&mqstat2, sizeof(mqstat2), 0, sizeof(mqstat2));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     mqstat2.mq_flags = 1;
 
     ret = mq_setattr(mqueue1, &mqstat1, NULL);
@@ -73,6 +77,7 @@ EXIT1:
     mq_close(mqueue1);
 EXIT:
     mq_unlink(mqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_070.cpp

@@ -44,8 +44,10 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq070_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq070_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
@@ -85,6 +87,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_071.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq071_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq071_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_072.cpp

@@ -43,7 +43,9 @@ static UINT32 Testcase(VOID)
     msgAttr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     msgAttr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(qName, MQUEUE_STANDARD_NAME_LENGTH, "/mq072_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qName, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq072_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
 
     msgQId = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
     ICUNIT_GOTO_NOT_EQUAL(msgQId, (mqd_t)-1, msgQId, EXIT);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_073.cpp

@@ -43,9 +43,13 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname1, MQUEUE_STANDARD_NAME_LENGTH, "/mq073_1_%d", LosCurTaskIDGet());
-    snprintf(mqname2, MQUEUE_STANDARD_NAME_LENGTH, "/mq073_2_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname1, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq073_1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    ret = snprintf_s(mqname2, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq073_2_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     mqueue1 = mq_open(mqname1, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue1, (mqd_t)-1, mqueue1, EXIT);
 
@@ -77,6 +81,7 @@ EXIT1:
 EXIT:
     mq_close(mqueue1);
     mq_unlink(mqname1);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_075.cpp

@@ -65,8 +65,9 @@ static UINT32 Testcase(VOID)
 
     g_testFlag = 1; // 1 initialize the flag
     LOS_TaskLock();
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq075_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq075_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT1);
     ret = pthread_attr_init(&attr1);
@@ -110,6 +111,7 @@ EXIT1:
     mq_unlink(mqname);
 EXIT:
     PosixPthreadDestroy(&attr1, pthread1);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_076.cpp

@@ -63,7 +63,9 @@ static VOID *PthreadF02(VOID *arg)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 2; // 2, queue max message size.
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq076_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq076_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT1);
@@ -103,6 +105,7 @@ EXIT1:
 EXIT:
     PosixPthreadDestroy(&attr1, thread1);
     g_testCount = 0;
+EXIT2:
     return NULL;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_077.cpp

@@ -64,8 +64,9 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq077_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq077_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT1);
 
@@ -104,6 +105,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_078.cpp

@@ -65,7 +65,9 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq078_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq078_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_ASSERT_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue);
@@ -107,6 +109,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_079.cpp

@@ -91,8 +91,10 @@ static UINT32 Testcase(VOID)
     pthread_attr_t attr1;
     struct sched_param schedparam;
 
-    memset(g_gqname, 0, MQUEUE_STANDARD_NAME_LENGTH);
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq079_%d", LosCurTaskIDGet());
+    ret = memset_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, 0, MQUEUE_STANDARD_NAME_LENGTH);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    (void)snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq079_%d", LosCurTaskIDGet());
 
     g_testCount = 0;
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_080.cpp

@@ -40,8 +40,10 @@ static UINT32 Testcase(VOID)
     INT32 unresolved = 0, failure = 0, i, maxreached = 0, ret = 0;
     unsigned pri;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq080-1_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq080-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MAXMSG5;
     queue = mq_open(qname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
@@ -50,7 +52,8 @@ static UINT32 Testcase(VOID)
     ts.tv_sec = 0;
     ts.tv_nsec = 0;
     for (i = 0; i < MAXMSG5 + 1; i++) {
-        snprintf(msgptr, MQUEUE_STANDARD_NAME_LENGTH, "message %d", i);
+        ret = snprintf_s(msgptr, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, "message %d", i);
+        ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
         ts.tv_sec++;
         if (mq_timedsend(queue, msgptr, strlen(msgptr), 0, &ts) == -1) {
             maxreached = 1;
@@ -77,6 +80,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(queue);
     mq_unlink(qname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_081.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     INT32 unresolved = 0, ret;
     unsigned pri;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq081-1_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq081-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MAXMSG5;
@@ -68,6 +70,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(queue);
     mq_unlink(qname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_082.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq082_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq082_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -67,6 +69,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_083.cpp

@@ -39,8 +39,9 @@ static UINT32 Testcase(VOID)
     mqd_t queue;
     INT32 unresolved = 0, failure = 0, i, maxreached = 0, ret = 0;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq083-1_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq083-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     attr.mq_msgsize = 100; // 100, queue message size.
     attr.mq_maxmsg = MAXMSG5;
     queue = mq_open(qname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
@@ -49,12 +50,14 @@ static UINT32 Testcase(VOID)
     ts.tv_sec = 1;
     ts.tv_nsec = 0;
     for (i = 0; i < MAXMSG5; i++) {
-        snprintf(msgptr, MQUEUE_STANDARD_NAME_LENGTH, "message %d", i);
+        ret = snprintf_s(msgptr, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, "message %d", i);
+        ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
         ret = mq_timedsend(queue, msgptr, strlen(msgptr), 0, &ts);
         ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT);
     }
 
-    snprintf(msgptr, MQUEUE_STANDARD_NAME_LENGTH, "message %d", i);
+    ret = snprintf_s(msgptr, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, "message %d", i);
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     ret = mq_timedsend(queue, msgptr, strlen(msgptr), 0, &ts);
     ICUNIT_GOTO_EQUAL(ret, -1, ret, EXIT);
     ICUNIT_GOTO_EQUAL(errno, EAGAIN, errno, EXIT);
@@ -69,6 +72,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(queue);
     mq_unlink(qname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_084.cpp

@@ -38,8 +38,9 @@ static UINT32 Testcase(VOID)
     mqd_t queue;
     INT32 unresolved = 0, failure = 0, ret = 0;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq084-1_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq084-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     queue = mq_open(qname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(queue, (mqd_t)-1, queue, EXIT);
 
@@ -59,6 +60,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(queue);
     mq_unlink(qname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_085.cpp

@@ -38,8 +38,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq085_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq085_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     mqueue = mq_open(mqname, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
@@ -60,6 +61,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_086.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "mq086_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "mq086_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -59,6 +61,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_087.cpp

@@ -39,8 +39,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq087_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq087_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
@@ -63,6 +64,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_088.cpp

@@ -40,8 +40,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq088_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq088_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     ts.tv_sec = 0;
     ts.tv_nsec = 0;
     for (i = 0; i < MQUEUE_PRIORITY_NUM_TEST; i++) {
@@ -68,6 +69,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_089.cpp

@@ -38,8 +38,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/tm/mq089_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/tm/mq089_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
@@ -59,6 +60,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_090.cpp

@@ -37,7 +37,8 @@ static UINT32 Testcase(VOID)
     INT32 i, unresolved = 0, failure = 0, numqueues = 0, ret;
 
     for (i = 0; (i < _POSIX_OPEN_MAX) && (i < _POSIX_MQ_OPEN_MAX); i++, numqueues++) {
-        snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq090%d_%d", i, LosCurTaskIDGet());
+        (void)snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                         "/mq090%d_%d", i, LosCurTaskIDGet());
 
         queue[i] = mq_open(qname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
         if (queue[i] == (mqd_t)-1) {
@@ -59,12 +60,14 @@ static UINT32 Testcase(VOID)
         ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     }
     for (i = 0; i < numqueues; i++) {
-        snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq090%d_%d", i, LosCurTaskIDGet());
+        (void)snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                         "/mq090%d_%d", i, LosCurTaskIDGet());
         ret = mq_unlink(qname);
         ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
     }
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq090%d_%d", numqueues, LosCurTaskIDGet());
+    (void)snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq090%d_%d", numqueues, LosCurTaskIDGet());
     ret = mq_unlink(qname);
     ICUNIT_GOTO_EQUAL(ret, -1, ret, EXIT);
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_091.cpp

@@ -38,8 +38,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq091_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq091_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
@@ -60,6 +61,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_093.cpp

@@ -40,8 +40,9 @@ static UINT32 Testcase(VOID)
     struct sigaction act;
     time_t currsec;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq093_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq093_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
 
@@ -71,6 +72,7 @@ EXIT1:
     mq_close(g_gqueue);
 EXIT:
     mq_unlink(g_gqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_094.cpp

@@ -38,8 +38,10 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq094_%d", LosCurTaskIDGet());
-
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq094_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
+    
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT);
 
@@ -61,6 +63,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_095.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq095_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq095_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
@@ -83,6 +85,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_096.cpp

@@ -40,9 +40,12 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr;
     struct timespec ts;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq096_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq096_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
-    memset(&attr, 0, sizeof(attr));
+    ret = memset_s(&attr, sizeof(attr), 0, sizeof(attr));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     attr.mq_msgsize = 20 + 1; // 20, queue message size.
     attr.mq_maxmsg = 20 + 1; // 20, queue max message size.
 
@@ -69,6 +72,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_097.cpp

@@ -92,7 +92,9 @@ static UINT32 Testcase(VOID)
     pthread_attr_t attr1;
     pthread_t newTh, newTh2;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq097_%d", LosCurTaskIDGet());
+    ret = snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq097_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -133,6 +135,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(g_gqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_098.cpp

@@ -36,7 +36,9 @@ static UINT32 Testcase(VOID)
     INT32 ret = 0;
     mqd_t queue;
 
-    snprintf(qname, MQUEUE_STANDARD_NAME_LENGTH, "/mq098_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq098_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     queue = mq_open(qname, O_CREAT | O_RDWR | O_WRONLY, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(queue, (mqd_t)-1, queue, EXIT);
@@ -51,6 +53,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(queue);
     mq_unlink(qname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_100.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq100_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq100_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -64,6 +66,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_101.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq101_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq101_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -73,6 +75,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_102.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq102_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq102_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -68,6 +70,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_103.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq103_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq103_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -68,6 +70,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_104.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq104_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq104_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -83,6 +85,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_106.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq106_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq106_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -64,6 +66,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_108.cpp

@@ -38,7 +38,9 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr = { 0 };
     INT32 unresolved = 0, failure = 0, ret = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq108-1_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq108-1_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -61,6 +63,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(mqdes);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_109.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq109_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq109_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -63,6 +65,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_110.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq110_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq110_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -63,6 +65,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_111.cpp

@@ -59,7 +59,9 @@ static VOID *PthreadF02(VOID *arg)
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq111_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq111_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT2);
@@ -95,6 +97,7 @@ EXIT1:
     mq_unlink(mqname);
 EXIT:
     pthread_join(pthread1, NULL);
+EXIT3:
     return NULL;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_112.cpp

@@ -61,7 +61,9 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(qName, MQUEUE_STANDARD_NAME_LENGTH, "/mq112_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qName, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq112_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
 
     g_messageQId = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
     ICUNIT_GOTO_NOT_EQUAL(g_messageQId, (mqd_t)-1, g_messageQId, EXIT);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_113.cpp

@@ -66,7 +66,9 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq113_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq113_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT2);
@@ -115,6 +117,7 @@ EXIT1:
     pthread_join(pthread1, NULL);
 EXIT:
     pthread_attr_destroy(&attr1);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_114.cpp

@@ -65,7 +65,9 @@ static UINT32 Testcase(VOID)
     g_testCount = 0;
 
     LOS_TaskLock();
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq114_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq114_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT2);
@@ -114,6 +116,7 @@ EXIT1:
     pthread_join(pthread1, NULL);
 EXIT:
     pthread_attr_destroy(&attr1);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_115.cpp

@@ -67,7 +67,9 @@ static UINT32 Testcase(VOID)
 
     LOS_TaskLock();
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq115_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq115_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT2);
@@ -113,6 +115,7 @@ EXIT1:
     pthread_join(pthread1, NULL);
 EXIT:
     pthread_attr_destroy(&attr1);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_116.cpp

@@ -43,7 +43,9 @@ static VOID *PthreadF01(VOID *arg)
 
     LOS_AtomicInc(&g_testCount);
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq116_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq116_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT1);
@@ -67,6 +69,7 @@ EXIT1:
 EXIT:
     mq_unlink(mqname);
     g_testCount = 0;
+EXIT2:
     return NULL;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_117.cpp

@@ -63,7 +63,9 @@ static UINT32 Testcase(VOID)
     g_testCount = 0;
 
     LOS_TaskLock();
-    snprintf(qName, MQUEUE_STANDARD_NAME_LENGTH, "/mq117_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qName, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq117_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
 
     g_messageQId = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
     ICUNIT_GOTO_NOT_EQUAL(g_messageQId, (mqd_t)-1, g_messageQId, EXIT2);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_118.cpp

@@ -99,7 +99,8 @@ static UINT32 Testcase(VOID)
 
     LOS_TaskLock();
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq118_%d", LosCurTaskIDGet());
+    (void)snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq118_%d", LosCurTaskIDGet());
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_119.cpp

@@ -77,7 +77,9 @@ static VOID *PthreadF02(VOID *arg)
 
     LOS_AtomicInc(&g_testCount);
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq119_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq119_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT);
@@ -117,6 +119,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(mqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_120.cpp

@@ -89,7 +89,8 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq120_%d", LosCurTaskIDGet());
+    (void)snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq120_%d", LosCurTaskIDGet());
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT1);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_121.cpp

@@ -141,7 +141,8 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(qName, MQUEUE_STANDARD_NAME_LENGTH, "/mq121_%d", LosCurTaskIDGet());
+    (void)snprintf_s(qName, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq121_%d", LosCurTaskIDGet());
 
     g_messageQId = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
     ICUNIT_GOTO_NOT_EQUAL(g_messageQId, (mqd_t)-1, g_messageQId, EXIT);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_122.cpp

@@ -68,7 +68,9 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq122_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq122_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT1);
@@ -101,6 +103,7 @@ EXIT1:
     mq_close(g_gqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_123.cpp

@@ -47,7 +47,9 @@ static VOID HwiF01(VOID *arg)
 
     LOS_AtomicInc(&g_testCount);
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq123_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq123_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT);
@@ -69,6 +71,7 @@ EXIT:
     mq_close(g_gqueue);
     mq_unlink(mqname);
     g_testCount = 0;
+EXIT1:
     return;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_124.cpp

@@ -98,10 +98,13 @@ EXIT:
 static UINT32 Testcase(VOID)
 {
     UINT32 uret;
+    INT32 ret;
 
     g_testCount = 0;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq124_%d", LosCurTaskIDGet());
+    ret = snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq124_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT);
 
     uret = LOS_HwiCreate(HWI_NUM_TEST1, 1, 0, (HWI_PROC_FUNC)HwiF02, 0);
     ICUNIT_GOTO_EQUAL(uret, MQUEUE_NO_ERROR, uret, EXIT);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_125.cpp

@@ -103,7 +103,9 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq125_%d", LosCurTaskIDGet());
+    ret = snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq125_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     ret = pthread_attr_init(&attr1);
     ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
@@ -145,6 +147,7 @@ EXIT1:
     pthread_join(pthread1, NULL);
 EXIT:
     pthread_attr_destroy(&attr1);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_126.cpp

@@ -100,7 +100,9 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq126_%d", LosCurTaskIDGet());
+    ret = snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq126_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     uret = LOS_HwiCreate(HWI_NUM_TEST, 0, 0, (HWI_PROC_FUNC)HwiF01, 0);
     ICUNIT_GOTO_EQUAL(uret, MQUEUE_NO_ERROR, uret, EXIT);
@@ -142,6 +144,7 @@ EXIT1:
     pthread_attr_destroy(&attr1);
 EXIT:
     TEST_HwiDelete(HWI_NUM_TEST);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_128.cpp

@@ -37,7 +37,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq128_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq128_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -60,6 +62,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_129.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq129_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq129_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -68,6 +70,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_130.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = 0;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq130_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq130_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT);
@@ -58,6 +60,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(mqname);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_133.cpp

@@ -88,7 +88,8 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(qName, MQUEUE_STANDARD_NAME_LENGTH, "/mq170_%d", LosCurTaskIDGet());
+    (void)snprintf_s(qName, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq170_%d", LosCurTaskIDGet());
 
     g_messageQId = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
     ICUNIT_GOTO_NOT_EQUAL(g_messageQId, (mqd_t)-1, g_messageQId, EXIT1);
@@ -148,7 +149,6 @@ EXIT2:
 EXIT1:
     mq_close(g_messageQId);
     mq_unlink(qName);
-EXIT:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_134.cpp

@@ -37,7 +37,9 @@ static UINT32 Testcase(VOID)
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq134_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq134_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -55,6 +57,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_136.cpp

@@ -46,7 +46,8 @@ static UINT32 Testcase(VOID)
     msgAttr.mq_maxmsg = 20; // 20, mqueue message size.
 
     for (index = 0; index < (LOSCFG_BASE_IPC_QUEUE_CONFIG - QUEUE_EXISTED_NUM); index++) {
-        snprintf(qName[index], MQUEUE_STANDARD_NAME_LENGTH, "/mq136_%d", index);
+        (void)snprintf_s(qName[index], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                         "/mq136_%d", index);
         queueID[index] = mq_open(qName[index], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
         ICUNIT_GOTO_NOT_EQUAL(queueID[index], (mqd_t)-1, queueID[index], EXIT);
     }

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_143.cpp

@@ -61,7 +61,9 @@ static UINT32 Testcase(VOID)
     attr.mq_maxmsg = size;
     attr.mq_flags = O_NONBLOCK;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq143_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq143_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_ASSERT_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue);
@@ -101,6 +103,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_144.cpp

@@ -92,12 +92,15 @@ static UINT32 Testcase(VOID)
     pthread_attr_t attr1;
     pthread_t newTh, newTh2;
 
-    memset(&mqstat, 0, sizeof(mqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     mqstat.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
     mqstat.mq_msgsize = MQUEUE_SHORT_ARRAY_LENGTH * 2; // 2, mqueue message size.
     mqstat.mq_flags = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq144_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq144_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT3);
 
     g_gqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO, &mqstat);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT);
@@ -144,6 +147,7 @@ EXIT1:
 EXIT:
     mq_close(g_gqueue);
     mq_unlink(mqname);
+EXIT3:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_145.cpp

@@ -125,12 +125,14 @@ static UINT32 Testcase(VOID)
     struct mq_attr mqstat;
     pthread_t pthreadSend1, pthreadSend2, pthreadRecev1, pthreadRecev2;
 
-    snprintf(mqname1, MQUEUE_STANDARD_NAME_LENGTH, "/mqueue145_1_%d", LosCurTaskIDGet());
-    snprintf(mqname2, MQUEUE_STANDARD_NAME_LENGTH, "/mqueue145_2_%d", LosCurTaskIDGet());
+    (void)snprintf_s(mqname1, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mqueue145_1_%d", LosCurTaskIDGet());
+    (void)snprintf_s(mqname2, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mqueue145_2_%d", LosCurTaskIDGet());
 
     g_testCount = 0;
 
-    memset(&mqstat, 0, sizeof(mqstat));
+    (void)memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
     mqstat.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
     mqstat.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     mqstat.mq_flags = 0;

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_146.cpp

@@ -98,7 +98,8 @@ static UINT32 Testcase(VOID)
 
     oflag = O_CREAT | O_NONBLOCK | O_RDWR;
 
-    memset(&mqstat, 0, sizeof(mqstat));
+    ret = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     mqstat.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
     mqstat.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     mqstat.mq_flags = 0;

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_147.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = 1;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq147_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq147_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_148.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     msgAttr.mq_msgsize = 0xFFF0;
     msgAttr.mq_maxmsg = 0xFFF0;
 
-    snprintf(qName, MQUEUE_STANDARD_NAME_LENGTH, "/mq148_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qName, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq148_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     g_messageQId = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
     ICUNIT_GOTO_EQUAL(g_messageQId, (mqd_t)-1, g_messageQId, EXIT);
@@ -57,6 +59,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(g_messageQId);
     mq_unlink(qName);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_149.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq149_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq149_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_150.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq150_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq150_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -66,6 +68,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_151.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq151_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq151_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -62,6 +64,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_152.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq152_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq152_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT);
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_153.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq153_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq153_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_154.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq154_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq154_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -65,6 +67,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_155.cpp

@@ -43,7 +43,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq155_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq155_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -71,6 +73,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_157.cpp

@@ -44,14 +44,16 @@ static UINT32 Testcase(VOID)
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
 
     for (i = 0; i < count; i++) {
-        snprintf(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, "mq157_%d_%d", LosCurTaskIDGet(), i);
+        (void)snprintf_s(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                         "mq157_%d_%d", LosCurTaskIDGet(), i);
 
         mqueue[i] = mq_open(mqname[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
         ICUNIT_GOTO_NOT_EQUAL(mqueue[i], (mqd_t)-1, mqueue[i], EXIT);
     }
 
 #ifndef LOSCFG_DEBUG_QUEUE
-    snprintf(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, "mq157_%d_%d", LosCurTaskIDGet(), i);
+    (void)snprintf_s(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "mq157_%d_%d", LosCurTaskIDGet(), i);
     mqueue[i] = mq_open(mqname[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_EQUAL(mqueue[i], (mqd_t)-1, mqueue[i], EXIT);
 #endif

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_159.cpp

@@ -44,14 +44,16 @@ static UINT32 Testcase(VOID)
     attr.mq_maxmsg = 20;
 
     for (i = 0; i < count; i++) {
-        snprintf(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, "mq158_%d_%d", LosCurTaskIDGet(), i);
+        (void)snprintf_s(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                         "mq158_%d_%d", LosCurTaskIDGet(), i);
 
         mqueue[i] = mq_open(mqname[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
         ICUNIT_GOTO_NOT_EQUAL(mqueue[i], (mqd_t)-1, mqueue[i], EXIT);
     }
 
 #ifndef LOSCFG_DEBUG_QUEUE
-    snprintf(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, "/mq158_%d", i);
+    (void)snprintf_s(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq158_%d", i);
     mqueue[i] = mq_open(mqname[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_EQUAL(mqueue[i], (mqd_t)(-1), mqueue[i], EXIT);
 #else

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_160.cpp

@@ -42,13 +42,15 @@ static VOID *PthreadF01(VOID *arg)
     attr.mq_maxmsg = 5; // 5, queue max message size.
 
     for (i = 0; i < count; i++, g_testCount++) {
-        snprintf(g_mqueueName[i], MQUEUE_STANDARD_NAME_LENGTH, "/mq160_%d_%d", LosCurTaskIDGet(), i);
+        (void)snprintf_s(g_mqueueName[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                         "/mq160_%d_%d", LosCurTaskIDGet(), i);
         g_mqueueId[i] = mq_open(g_mqueueName[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
         ICUNIT_GOTO_NOT_EQUAL(g_mqueueId[i], (mqd_t)-1, g_mqueueId[i], EXIT);
     }
 
 #ifndef LOSCFG_DEBUG_QUEUE
-    snprintf(g_mqueueName[i], MQUEUE_STANDARD_NAME_LENGTH, "/mq160_%d_%d", LosCurTaskIDGet(), i);
+    (void)snprintf_s(g_mqueueName[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq160_%d_%d", LosCurTaskIDGet(), i);
     g_mqueueId[i] = mq_open(g_mqueueName[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_EQUAL(g_mqueueId[i], (mqd_t)-1, g_mqueueId[i], EXIT);
 #endif

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_161.cpp

@@ -44,7 +44,8 @@ static VOID *PthreadF01(VOID *arg)
 
     uret = g_index % count;
 
-    snprintf(g_mqueueName[uret], MQUEUE_STANDARD_NAME_LENGTH, "/mqueue_161_%d_%d", LosCurTaskIDGet(), (uret));
+    (void)snprintf_s(g_mqueueName[uret], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mqueue_161_%d_%d", LosCurTaskIDGet(), (uret));
     g_mqueueId[uret] = mq_open(g_mqueueName[uret], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_mqueueId[uret], (mqd_t)-1, g_mqueueId[uret], EXIT);
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_162.cpp

@@ -76,7 +76,6 @@ static UINT32 Testcase(VOID)
 {
     INT32 oflag, i, ret = 0;
     INT32 pthreadCount[MQUEUE_PTHREAD_NUM_TEST];
-
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     pthread_t pthreadSend[MQUEUE_PTHREAD_NUM_TEST];
     pthread_t pthreadRecev[MQUEUE_PTHREAD_NUM_TEST];
@@ -88,18 +87,16 @@ static UINT32 Testcase(VOID)
 
     g_testCount = 0;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq162_%d", LosCurTaskIDGet());
-
-    memset(&mqstat, 0, sizeof(mqstat));
+    (void)snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq162_%d", LosCurTaskIDGet());
+    (void)memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
     mqstat.mq_maxmsg = MQUEUE_PTHREAD_NUM_TEST;
     mqstat.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     mqstat.mq_flags = 0;
 
     oflag = O_CREAT | O_NONBLOCK | O_RDWR;
-
     g_gqueue = mq_open(mqname, oflag,  S_IRWXU | S_IRWXG | S_IRWXO, &mqstat);
     ICUNIT_GOTO_NOT_EQUAL(g_gqueue, (mqd_t)-1, g_gqueue, EXIT1);
-
     for (i = 0; i < MQUEUE_PTHREAD_NUM_TEST; i++) {
         pthreadCount[i] = i;
         ret = pthread_create(&pthreadSend[i], &attr1, PthreadF01, NULL);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_163.cpp

@@ -42,13 +42,15 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
     for (i = 0; i < (count); i++) {
-        snprintf(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, "/mq163_%d_%d", LosCurTaskIDGet(), i);
+        (void)snprintf_s(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                         "/mq163_%d_%d", LosCurTaskIDGet(), i);
         mqueue[i] = mq_open(mqname[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
         ICUNIT_GOTO_NOT_EQUAL(mqueue[i], (mqd_t)-1, mqueue[i], EXIT);
     }
 
 #ifndef LOSCFG_DEBUG_QUEUE
-    snprintf(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, "/mq163_%d_%d", LosCurTaskIDGet(), i);
+    (void)snprintf_s(mqname[i], MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq163_%d_%d", LosCurTaskIDGet(), i);
     mqueue[i] = mq_open(mqname[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_EQUAL(mqueue[i], (mqd_t)-1, mqueue[i], EXIT1);
     ICUNIT_GOTO_EQUAL(errno, ENFILE, errno, EXIT1);

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_164.cpp

@@ -43,7 +43,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 3; // 3, queue max message size.
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq164_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq164_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -75,6 +77,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_165.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 3; // 3, queue max message size.
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq165_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq165_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -66,6 +68,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_166.cpp

@@ -46,7 +46,9 @@ static UINT32 Testcase(VOID)
     msgAttr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     msgAttr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
-    snprintf(qName, MQUEUE_STANDARD_NAME_LENGTH, "/mq166_%d", LosCurTaskIDGet());
+    ret = snprintf_s(qName, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq166_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     msgQId = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &msgAttr);
     ICUNIT_GOTO_NOT_EQUAL(msgQId, (mqd_t)-1, msgQId, EXIT);
@@ -82,6 +84,7 @@ static UINT32 Testcase(VOID)
 EXIT:
     mq_close(msgQId);
     mq_unlink(qName);
+EXIT1:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_168.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq168_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq168_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -84,6 +86,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_169.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr = { 0 };
     struct timespec ts;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq169_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq169_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -80,6 +82,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_173.cpp

@@ -42,7 +42,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq173_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq173_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -69,6 +71,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_175.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     struct mq_attr attr = { 0 };
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq175_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq175_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -85,6 +87,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_176.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq176_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq176_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -75,6 +77,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_177.cpp

@@ -41,7 +41,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq177_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq177_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_SHORT_ARRAY_LENGTH;
@@ -71,6 +73,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_187.cpp

@@ -36,7 +36,9 @@ static UINT32 Testcase(VOID)
     CHAR mqname[MQUEUE_STANDARD_NAME_LENGTH] = "";
     mqd_t mqueue;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq187_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq187_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_NONBLOCK, S_IRUSR | S_IWUSR, 0);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
@@ -61,6 +63,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_200.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq200_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq200_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -68,6 +70,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_201.cpp

@@ -44,7 +44,9 @@ static UINT32 Testcase(VOID)
     attr.mq_msgsize = 20; // 20, queue message size.
     attr.mq_maxmsg = 20; // 20, queue max message size.
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq201_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq201_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     mqueue = mq_open(mqname, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_ASSERT_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue);
@@ -71,6 +73,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_202.cpp

@@ -39,7 +39,9 @@ static UINT32 Testcase(VOID)
     struct timespec ts;
     struct mq_attr attr = { 0 };
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq202_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq202_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT2);
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
@@ -66,6 +68,7 @@ EXIT1:
     mq_close(mqueue);
 EXIT:
     mq_unlink(mqname);
+EXIT2:
     return MQUEUE_NO_ERROR;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_203.cpp

@@ -40,7 +40,9 @@ static UINT32 Testcase(VOID)
     mqd_t mqueue1, mqueue2;
     struct timespec ts;
 
-    snprintf(mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq203_%d", LosCurTaskIDGet());
+    ret = snprintf_s(mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1, \
+                     "/mq203_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
@@ -59,6 +61,7 @@ EXIT:
     mq_close(mqueue1);
     mq_close(mqueue2);
     mq_unlink(mqname);
+EXIT1:
     return LOS_OK;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_204.cpp

@@ -74,7 +74,9 @@ STATIC UINT32 Testcase(VOID)
     pthread_t pthread1, pthread2;
     pthread_attr_t attr1, attr2;
 
-    snprintf(g_mqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq204_%d", LosCurTaskIDGet());
+    ret = snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH,
+                     "/mq204_%d", LosCurTaskIDGet());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
     g_attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     g_attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;
 
@@ -93,6 +95,7 @@ STATIC UINT32 Testcase(VOID)
 EXIT:
     (VOID)pthread_join(pthread1, NULL);
     (VOID)pthread_join(pthread2, NULL);
+EXIT1:
     return LOS_OK;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_205.cpp

@@ -58,7 +58,8 @@ static void Child(void)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 1;
 
-    (void)snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq205_%d", getpid());
+    ret = snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq205_%d", getpid());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     g_mqueue = mq_open(g_mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_mqueue, (mqd_t)-1, g_mqueue, EXIT);
@@ -88,6 +89,7 @@ static void Child(void)
 EXIT:
     mq_close(g_mqueue);
     mq_unlink(g_mqname);
+EXIT1:
     return;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_207.cpp

@@ -59,7 +59,8 @@ static void Child(void)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 1;
 
-    (void)snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq207_%d", getpid());
+    ret = snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq207_%d", getpid());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     g_mqueue = mq_open(g_mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_mqueue, (mqd_t)-1, g_mqueue, EXIT);
@@ -86,6 +87,7 @@ static void Child(void)
 EXIT:
     mq_close(g_mqueue);
     mq_unlink(g_mqname);
+EXIT1:
     return;
 }
 

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_208.cpp

@@ -59,7 +59,8 @@ static void Child(void)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 3; // 3, queue max message size.
 
-    (void)snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq208_%d", getpid());
+    ret = snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq208_%d", getpid());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     g_mqueue = mq_open(g_mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_mqueue, (mqd_t)-1, g_mqueue, EXIT);
@@ -113,6 +114,7 @@ static void Child(void)
 EXIT:
     mq_close(g_mqueue);
     mq_unlink(g_mqname);
+EXIT1:
     return;
 }
 static UINT32 Testcase(VOID)

testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_209.cpp

@@ -78,7 +78,8 @@ static void Child(void)
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = 3; // 3, queue max message size.
 
-    (void)snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq209_%d", getpid());
+    ret = snprintf_s(g_mqname, MQUEUE_STANDARD_NAME_LENGTH - 1, MQUEUE_STANDARD_NAME_LENGTH, "/mq209_%d", getpid());
+    ICUNIT_GOTO_NOT_EQUAL(ret, MQUEUE_IS_ERROR, ret, EXIT1);
 
     g_mqueue = mq_open(g_mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
     ICUNIT_GOTO_NOT_EQUAL(g_mqueue, (mqd_t)-1, g_mqueue, EXIT);
@@ -122,6 +123,7 @@ static void Child(void)
 EXIT:
     mq_close(g_mqueue);
     mq_unlink(g_mqname);
+EXIT1:
     return;
 }
 static UINT32 Testcase(VOID)

testsuites/unittest/libc/posix/mqueue/smoke/It_posix_queue_053.cpp

@@ -87,7 +87,8 @@ static UINT32 Testcase(VOID)
     pthread_attr_t attr1;
     pthread_t newTh1, newTh2;
 
-    snprintf(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, "/mq053_%d", LosCurTaskIDGet());
+    (void)snprintf_s(g_gqname, MQUEUE_STANDARD_NAME_LENGTH, MQUEUE_STANDARD_NAME_LENGTH - 1,
+                     "/mq053_%d", LosCurTaskIDGet());
 
     attr.mq_msgsize = MQUEUE_STANDARD_NAME_LENGTH;
     attr.mq_maxmsg = MQUEUE_STANDARD_NAME_LENGTH;

testsuites/unittest/libc/posix/mqueue/smoke/It_posix_queue_062.cpp

@@ -44,8 +44,10 @@ static UINT32 Testcase(VOID)
     mqueue = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
     ICUNIT_GOTO_NOT_EQUAL(mqueue, (mqd_t)-1, mqueue, EXIT1);
 
-    (void)memset_s(&mqstat1, sizeof(mqstat1), 0, sizeof(mqstat1));
-    (void)memset_s(&mqstat2, sizeof(mqstat2), 0, sizeof(mqstat2));
+    ret = memset_s(&mqstat1, sizeof(mqstat1), 0, sizeof(mqstat1));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
+    ret = memset_s(&mqstat2, sizeof(mqstat2), 0, sizeof(mqstat2));
+    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
 
     ret = mq_getattr(mqueue, &mqstat1);
     ICUNIT_GOTO_EQUAL(ret, MQUEUE_NO_ERROR, ret, EXIT1);

testsuites/unittest/libc/time/timer/smoke/timer_test_005.cpp

@@ -65,7 +65,8 @@ static int TimerTest(void)
     int ret;
     int i;
 
-    (void)memset(&sev, 0, sizeof(struct sigevent));
+    ret = memset_s(&sev, sizeof(struct sigevent), 0, sizeof(struct sigevent));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     sev.sigev_notify = SIGEV_THREAD;
     sev.sigev_notify_function = TempSigHandler;
     sev.sigev_value.sival_ptr = (void *)TempSigHandler01;

testsuites/unittest/net/socket/smoke/net_socket_test_010.cpp

@@ -77,7 +77,8 @@ static unsigned IfName2Index(int fd, const char *name)
     struct ifreq ifr;
     int ret;
 
-    (void)strncpy_s(ifr.ifr_name, sizeof(ifr.ifr_name) - 1, name, sizeof(ifr.ifr_name) - 1);
+    ret = strncpy_s(ifr.ifr_name, sizeof(ifr.ifr_name) - 1, name, sizeof(ifr.ifr_name) - 1);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
     ret = ioctl(fd, SIOCGIFINDEX, &ifr);
     return ret < 0 ? 0 : ifr.ifr_ifindex;

testsuites/unittest/process/lock/rwlock/full/pthread_rwlock_test_002.cpp

@@ -227,7 +227,8 @@ static int PthreadRwlockTest(void)
     int index = 0;
     int curThreadPri, curThreadPolicy;
 
-    (void)memset_s((void *)g_rwlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ret = memset_s((void *)g_rwlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     g_rwlockMask = 0;
 
     pthread_rwlock_init(&g_rwlockLock, NULL);

testsuites/unittest/process/lock/rwlock/smoke/pthread_rwlock_test_001.cpp

@@ -227,7 +227,8 @@ static int Testcase(void)
     int index = 0;
     int curThreadPri, curThreadPolicy;
 
-    (void)memset_s((void *)g_rwlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ret = memset_s((void *)g_rwlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     g_rwlockMask = 0;
 
     pthread_rwlock_init(&g_rwlockLock, NULL);

testsuites/unittest/process/lock/spinlock/smoke/pthread_spinlock_test_001.cpp

@@ -134,7 +134,8 @@ static int Testcase(void)
     int index = 0;
     int curThreadPri, curThreadPolicy;
 
-    (void)memset_s((void *)g_spinlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ret = memset_s((void *)g_spinlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     g_spinlockMask = 0;
 
     pthread_spin_init(&g_spinlockLock, 0);