diff --git a/fs/proc/src/proc_file.c b/fs/proc/src/proc_file.c
index 27264da1a9735ae5575417389903def8dd877669..e26283e43c245b7741cf07999a75366e22f265aa 100644
--- a/fs/proc/src/proc_file.c
+++ b/fs/proc/src/proc_file.c
@@ -62,8 +62,9 @@ static struct ProcDirEntry g_procRootDirEntry = {
 
 int ProcMatch(unsigned int len, const char *name, struct ProcDirEntry *pn)
 {
-    if (len != pn->nameLen)
+    if (len != pn->nameLen) {
         return 0;
+    }
     return !strncmp(name, pn->name, len);
 }
 
@@ -387,8 +388,9 @@ static void FreeProcEntry(struct ProcDirEntry *entry)
 
 void ProcFreeEntry(struct ProcDirEntry *pn)
 {
-    if (atomic_dec_and_test(&pn->count))
+    if (atomic_dec_and_test(&pn->count)) {
         FreeProcEntry(pn);
+    }
 }
 
 static void RemoveProcEntryTravalsal(struct ProcDirEntry *pn)
diff --git a/fs/vfs/vfs_cmd/vfs_shellcmd.c b/fs/vfs/vfs_cmd/vfs_shellcmd.c
index 33324811c4ade8334bdb11e792b1df72f20e2af0..43129316028a3d4559b8bf66e65bbb82402386d0 100644
--- a/fs/vfs/vfs_cmd/vfs_shellcmd.c
+++ b/fs/vfs/vfs_cmd/vfs_shellcmd.c
@@ -344,7 +344,7 @@ int osShellCmdMount(int argc, const char **argv)
 
         filessystemtype = (argc >= 4) ? (char *)argv[3] : NULL; /* 4: specify fs type, 3: fs type */
         mountfalgs = (argc >= 5) ? get_mountflags((const char *)argv[4]) : 0; /* 4: usr option */
-        data = (argc >= 6) ? (char *)argv[5] : NULL; /* 5: usr option data */
+        data = (argc >= 6) ? (char *)argv[5] : NULL; /* 5: usr option data, 6: six args needed for data */
 
         if (strcmp(argv[1], "0") == 0) {
             ret = mount((const char *)NULL, fullpath, filessystemtype, mountfalgs, data);
@@ -384,7 +384,7 @@ int osShellCmdMount(int argc, const char **argv)
         }
 
         mountfalgs = (argc >= 4) ? get_mountflags((const char *)argv[3]) : 0;  /* 3: usr option */
-        data = (argc >= 5) ? (char *)argv[4] : NULL; /* 4: usr option data */
+        data = (argc >= 5) ? (char *)argv[4] : NULL; /* 4: usr option data, 5: number of args needed for data */
 
         if (strcmp(argv[0], "0") == 0) {
             ret = mount((const char *)NULL, fullpath, argv[2], mountfalgs, data);
diff --git a/kernel/common/console.c b/kernel/common/console.c
index e6973918bd5a2b8c702e916bf04ffc89f4d8a89e..896d332b5c1388f5247eff24cbfa3e1755d770d1 100644
--- a/kernel/common/console.c
+++ b/kernel/common/console.c
@@ -404,7 +404,7 @@ STATIC VOID EchoToTerminal(CONSOLE_CB *consoleCB, struct file *filep, const stru
 {
     if (consoleCB->consoleTermios.c_lflag & ECHO) {
         if (ch == '\b') {
-            (VOID)fops->write(filep, "\b \b", 3);
+            (VOID)fops->write(filep, "\b \b", 3); // 3: length of "\b \b"
         } else {
             (VOID)fops->write(filep, &ch, EACH_CHAR);
         }
diff --git a/net/lwip-2.1/porting/include/arch/perf.h b/net/lwip-2.1/porting/include/arch/perf.h
index dea6a6946fd0fcef33caa75031a8893d794011a4..cc200260e0e363be889c4a27ab3d4095d8a337b5 100644
--- a/net/lwip-2.1/porting/include/arch/perf.h
+++ b/net/lwip-2.1/porting/include/arch/perf.h
@@ -34,8 +34,8 @@
 
 #if LWIP_PERF
 
-#define PERF_START    do {/* something to do */} while (0)
-#define PERF_STOP(x)  do {/* something to do */} while (0)
+#define PERF_START    do {} while (0) /* something to do */
+#define PERF_STOP(x)  do {} while (0) /* something to do */
 
 #endif
 
diff --git a/testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_027.c b/testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_027.c
index ea0324c649f124b02c6bda250877cf815ee2fa8e..5754cbd9b66ad88ccbf58481c51f8cb483e5389d 100644
--- a/testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_027.c
+++ b/testsuites/kernel/sample/kernel_base/ipc/event/full/It_los_event_027.c
@@ -48,8 +48,9 @@ static VOID SwtmrF01(VOID)
 
     g_eventMask = g_eventMask | (1 << g_testCount);
 
-    if (g_testCount > 17) // g_testCount > 17, do noting return
+    if (g_testCount > 17) { // g_testCount > 17, do noting return
         return;
+    }
 
     ret = LOS_EventWrite(&g_event, g_eventMask);
     ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
diff --git a/testsuites/kernel/sample/kernel_base/ipc/sem/smp/It_smp_los_sem_026.c b/testsuites/kernel/sample/kernel_base/ipc/sem/smp/It_smp_los_sem_026.c
index 76c8490c1dd6be069a2d2e388084d2365fb05c77..5b530340113513a34ed464684e741c448bd41718 100644
--- a/testsuites/kernel/sample/kernel_base/ipc/sem/smp/It_smp_los_sem_026.c
+++ b/testsuites/kernel/sample/kernel_base/ipc/sem/smp/It_smp_los_sem_026.c
@@ -104,9 +104,9 @@ static UINT32 Testcase(VOID)
 
     TestAssertBusyTaskDelay(100, 3); // 100, Set the timeout of runtime; 3, test running count
     ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 3, Here, assert that g_testCount is equal to
-    if ((g_ret1 + g_ret2 == 0xff) && (TestAbs(g_ret1, g_ret2) == 0xff))
+    if ((g_ret1 + g_ret2 == 0xff) && (TestAbs(g_ret1, g_ret2) == 0xff)) {
         ICUNIT_GOTO_EQUAL(1, 1, g_ret1, EXIT);
-    else {
+    } else {
         ICUNIT_GOTO_EQUAL(1, 0, g_ret1, EXIT);
     }
     PRINT_DEBUG("ret1=0x%x,ret2=0x%x\n", g_ret1, g_ret2);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_035.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_035.c
index 08bad1b722dc64d01b0149a434977a6b06bfae6f..2af191f0b6b7bd73ec617d1dee016f9af9acbe88 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_035.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_035.c
@@ -105,8 +105,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh3, NULL, PthreadF03, NULL);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    while (g_testCount < 6) // 6, wait until g_testCount is equal to 6.
+    while (g_testCount < 6) { // 6, wait until g_testCount is equal to 6.
         sleep(1);
+    }
 
     ICUNIT_ASSERT_EQUAL(g_testCount, 6, g_testCount); // 6, here assert the result.
 
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_080.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_080.c
index 1abd1b91748d5ce52eb669ab53345f8d39dad8ac..eb65ad2811692d5cc4982bc34e01cb35e04a6615 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_080.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_080.c
@@ -75,8 +75,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(100); // 100, delay for Timing control.
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_081.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_081.c
index b7ee988c62d86c36b616a2f7f9a9f884aa9ab26d..70163aa3044bbe0dd7e11989a014b5b7868026aa 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_081.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_081.c
@@ -80,8 +80,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(100); // 100, delay for Timing control.
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_082.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_082.c
index 6a30d5715cc8de36aad73126be9a34e1d4b41be5..65d71060119b7c3c92055f4524a09244eb6aa413 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_082.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_082.c
@@ -87,8 +87,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(100); // 100, delay for Timing control.
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_083.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_083.c
index 4398444a811419a48cda862b882511aeed0e504f..32aacfb770d322a0ef8c9a1aa52761078c6b82b3 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_083.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_083.c
@@ -76,8 +76,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(100); // 100, delay for Timing control.
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_084.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_084.c
index 0f54d29801e6e1f5dfc88c33d9a9a15f9ea2b9e5..b749f8eb5002f16293ea0c6f68d416685415e401 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_084.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_084.c
@@ -79,8 +79,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(100); // 100, delay for Timing control.
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_085.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_085.c
index 1e2136f96fa2fa5c7a85da8a571cecb687fb08ea..f55e50ff9bb6fdc7846c4fc666a14cd29cd3161e 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_085.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_085.c
@@ -75,8 +75,9 @@ static UINT32 Testcase(VOID)
     rc = pthread_create(&thread1, NULL, PthreadF01, NULL);
     ICUNIT_ASSERT_EQUAL(rc, 0, rc);
 
-    while (!g_t1Start) /* wait for thread1 started */
+    while (!g_t1Start) { /* wait for thread1 started */
         usleep(100); // 100, delay for Timing control.
+    }
 
     /* acquire the mutex released by pthread_cond_wait() within thread 1 */
     rc = pthread_mutex_lock(&g_td.mutex);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_088.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_088.c
index 50870b067f6639ede0cdcbc9c07ce04719892306..8e6a9c61b8c90c830f7ce34167a3abb94bf97340 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_088.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_088.c
@@ -114,8 +114,9 @@ static void *PthreadF02(void *tmp)
     clock_gettime(CLOCK_REALTIME, &startTime);
     while (1) {
         clock_gettime(CLOCK_REALTIME, &currentTime);
-        if (PthreadTimeF01(currentTime, startTime) > RUNTIME)
+        if (PthreadTimeF01(currentTime, startTime) > RUNTIME) {
             break;
+        }
     }
     g_lowDone = 1;
 EXIT:
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_089.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_089.c
index 7b4f6460f09648df5cace19832f259df82f4dd0d..3fa8a48ca692713c031fe8f6d206b9f73c6d9e12 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_089.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_089.c
@@ -115,8 +115,9 @@ static void *PthreadF02(void *tmp)
     clock_gettime(CLOCK_REALTIME, &startTime);
     while (1) {
         clock_gettime(CLOCK_REALTIME, &currentTime);
-        if (PthreadTimeF01(currentTime, startTime) > RUNTIME)
+        if (PthreadTimeF01(currentTime, startTime) > RUNTIME) {
             break;
+        }
     }
     g_lowDone = 1;
 EXIT:
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_138.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_138.c
index 1df4161710833b5f30e5f88f98f5312189bbdf9e..9ea3914271b5f3eed8bf2dafc79a5eeb4c44a2af 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_138.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_138.c
@@ -58,8 +58,9 @@ static UINT32 Testcase(VOID)
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
     /* Make sure the thread was created before we join it. */
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_join(newTh, &valuePtr);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_215.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_215.c
index aa768427f929514cbb7dfcfd4f74a161d435c362..e50a42abfb9647cd8de7d66bb943e3fb82923fd8 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_215.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_215.c
@@ -77,8 +77,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, PthreadF01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_testCount == 0)
+    while (g_testCount == 0) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_233.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_233.c
index fb2ea6d94b3f51bf41f7aea8f352aa3185365b95..273e386b9e297d5e1cd347b036c6e1abdf854725 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_233.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_233.c
@@ -76,8 +76,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, PthreadF01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == 0)
+    while (g_pthreadSem == 0) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_238.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_238.c
index 61bcc22682a7d3a2583afe7c9305ad1fb6cf3d38..5a8723c1585b8b0a272f1ecec282b94ca3bcdaaa 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_238.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_238.c
@@ -51,8 +51,9 @@ static VOID *PthreadF01(VOID *argument)
 
     g_pthreadSem = PTHREAD_INMAIN_TEST;
 
-    while (g_pthreadSem == PTHREAD_INMAIN_TEST)
+    while (g_pthreadSem == PTHREAD_INMAIN_TEST) {
         sleep(1);
+    }
 
     pthread_testcancel();
 
@@ -73,8 +74,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, PthreadF01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_239.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_239.c
index ecfa59f82937e395a78ad4a329a523f2a37cb32e..0d611e8d5742e677f1c44af86d3d46ad178c9e9c 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_239.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_239.c
@@ -48,8 +48,9 @@ static VOID *PthreadF01(VOID *argument)
 
     g_pthreadSem = PTHREAD_INMAIN_TEST;
 
-    while (g_pthreadSem == PTHREAD_INMAIN_TEST)
+    while (g_pthreadSem == PTHREAD_INMAIN_TEST) {
         sleep(1);
+    }
 
     pthread_testcancel();
 
@@ -69,8 +70,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, PthreadF01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_240.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_240.c
index 683149432192fb9c816d45e2525b29660e41d697..8a2880699a9474289a445643d37dc7504508a29c 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_240.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_240.c
@@ -48,8 +48,9 @@ static VOID *PthreadF01(VOID *argument)
 
     g_pthreadSem = PTHREAD_INMAIN_TEST;
 
-    while (g_pthreadSem == PTHREAD_INMAIN_TEST)
+    while (g_pthreadSem == PTHREAD_INMAIN_TEST) {
         sleep(1);
+    }
 
     pthread_testcancel();
 
@@ -70,8 +71,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, PthreadF01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_246.c b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_246.c
index abb30a2b84eb426e8941f3313d932b9681e995dd..5c341c8804e2fa19cd56b6deef9834288c94db9b 100644
--- a/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_246.c
+++ b/testsuites/kernel/sample/posix/pthread/full/It_posix_pthread_246.c
@@ -48,8 +48,9 @@ static VOID *PthreadF01(VOID *argument)
 
     g_pthreadSem = PTHREAD_INMAIN_TEST;
 
-    while (g_pthreadSem == PTHREAD_INMAIN_TEST)
+    while (g_pthreadSem == PTHREAD_INMAIN_TEST) {
         sleep(1);
+    }
 
     pthread_testcancel();
 
@@ -71,8 +72,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, PthreadF01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/kernel/src/iCunit.c b/testsuites/kernel/src/iCunit.c
index c405161999c2c8c0e5716f0ad8f2b69069a1e6c7..ad014b197826992c191ff78f095083d234f1df2e 100644
--- a/testsuites/kernel/src/iCunit.c
+++ b/testsuites/kernel/src/iCunit.c
@@ -202,10 +202,11 @@ iUINT32 ICunitInit(void)
 
 iUINT32 ICunitRunSingle(ICUNIT_CASE_S *psubCase)
 {
-    if ((g_isSpinorInit == FALSE) && (psubCase->testcase_module == TEST_JFFS))
+    if ((g_isSpinorInit == FALSE) && (psubCase->testcase_module == TEST_JFFS)) {
         dprintf("****** Jffs is not support ! ******  \n");
-    else
+    } else {
         ICunitRunF(psubCase);
+    }
 
     return (iUINT32)ICUNIT_SUCCESS;
 }
diff --git a/testsuites/kernel/src/osTest.c b/testsuites/kernel/src/osTest.c
index 9605f3f7157640d7125003fea98f1d9cf1d1f67d..151a1645197b73a50655ec6a29af62a7f3ea73b7 100644
--- a/testsuites/kernel/src/osTest.c
+++ b/testsuites/kernel/src/osTest.c
@@ -315,8 +315,9 @@ VOID TestTestHwiDelete(unsigned int irq, VOID *devId)
 {
     HwiIrqParam stuwIrqPara;
 
-    if (OS_INT_ACTIVE)
+    if (OS_INT_ACTIVE) {
         return;
+    }
 
     stuwIrqPara.swIrq = irq;
     stuwIrqPara.pDevId = devId;
diff --git a/testsuites/unittest/basic/dynload/smoke/dynload_test_002.cpp b/testsuites/unittest/basic/dynload/smoke/dynload_test_002.cpp
index 7a175f77f80cf2ea4e834ec66022e3cbc5d34dc6..f6fd26a5c45f2bff4411b4d8f9a8d44037d8b26f 100644
--- a/testsuites/unittest/basic/dynload/smoke/dynload_test_002.cpp
+++ b/testsuites/unittest/basic/dynload/smoke/dynload_test_002.cpp
@@ -55,7 +55,7 @@ static int Testcase(void)
     handle = dlopen(LIBCSO_REAL_PATH, RTLD_NOW);
     ICUNIT_ASSERT_NOT_EQUAL(handle, NULL, handle);
 
-    func = (int (*)(int))dlsym(handle, SYMBOL_TO_FIND);
+    func = reinterpret_cast<int (*)(int)>(dlsym(handle, SYMBOL_TO_FIND));
     ICUNIT_GOTO_NOT_EQUAL(func, NULL, func, EXIT);
     ICUNIT_GOTO_EQUAL(func, SYMBOL_TO_MATCH, func, EXIT);
 
@@ -65,7 +65,7 @@ static int Testcase(void)
     handle = dlopen(LIBCSO_RELATIVE_PATH, RTLD_NOW);
     ICUNIT_ASSERT_NOT_EQUAL(handle, NULL, handle);
 
-    func = (int (*)(int))dlsym(handle, SYMBOL_TO_FIND);
+    func = reinterpret_cast<int (*)(int)>(dlsym(handle, SYMBOL_TO_FIND));
     ICUNIT_GOTO_NOT_EQUAL(func, NULL, func, EXIT);
 
     ret = dlclose(handle);
diff --git a/testsuites/unittest/basic/mem/shm/full/it_test_mem_100.cpp b/testsuites/unittest/basic/mem/shm/full/it_test_mem_100.cpp
index addcc3d673887f793b5b0109da71181fb1453222..918a6aebe42560a15533f3b7a1af13e1c7d2d180 100644
--- a/testsuites/unittest/basic/mem/shm/full/it_test_mem_100.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/it_test_mem_100.cpp
@@ -41,7 +41,7 @@ static int TestCase(void)
     wchar_t res2[] = L"abcdmngh";
     wchar_t *p, *pnew;
 
-    pnew = (wchar_t*)malloc(sizeof(wchar_t) * (wcslen(res) + wcslen(res1)));
+    pnew = static_cast<wchar_t *>(malloc(sizeof(wchar_t) * (wcslen(res) + wcslen(res1))));
     ICUNIT_ASSERT_NOT_EQUAL(pnew, NULL, pnew);
 
     p = wmempcpy(pnew, res, wcslen(res));
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_001.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_001.cpp
index 6cb107d3ae7b4fb8f861e4d8dd9db669323d737b..7582e132bba2ce98c9f47f48ba2d1f47eb9ed096 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_001.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_001.cpp
@@ -91,7 +91,7 @@ VOID *ShmWriteFunc(VOID *ptr)
     shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);
     ICUNIT_ASSERT_NOT_EQUAL_NULL_VOID(shmid, -1, shmid);
 
-    shm = shmat(shmid, (void *)0, 0);
+    shm = shmat(shmid, nullptr, 0);
     ICUNIT_ASSERT_NOT_EQUAL_NULL_VOID(shm, INVALID_PTR, shm);
 
     printf("Memory attached at %p\n", shm);
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_005.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_005.cpp
index 2e0da0ceae599d99476e51814647f54e7f5d57fd..b4d6ba61f871bfb488683395a32784cb2ba46434 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_005.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_005.cpp
@@ -49,13 +49,13 @@ static int Testcase(VOID)
     shm = shmat(shmid, NULL, SHM_REMAP);
     ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
 
-    shm = shmat(shmid, (const void *)0x100, 0);
+    shm = shmat(shmid, reinterpret_cast<const void *>(0x100), 0);
     ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
 
     shm = shmat(shmid, NULL, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(shm, (void *)-1, shm);
+    ICUNIT_ASSERT_NOT_EQUAL(shm, reinterpret_cast<void *>(-1), shm);
 
-    ret = shmdt((const void *)0x100);
+    ret = shmdt(reinterpret_cast<const void *>(0x100));
     ICUNIT_ASSERT_EQUAL(ret, -1, shmid);
     ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
 
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_006.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_006.cpp
index 4b78d6f4a3b9f220418b29165242685bfb951064..46f52a4dbb1025918964cfc7463734aebddc8e63 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_006.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_006.cpp
@@ -42,14 +42,14 @@ static int Testcase(VOID)
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     shared = shmat(shmid, 0, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(shared, (void *)-1, shared);
+    ICUNIT_ASSERT_NOT_EQUAL(shared, reinterpret_cast<void *>(-1), shared);
 
     ret = shmdt(shared);
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
 
     remap = shared;
     shared = shmat(shmid, remap, SHM_REMAP);
-    ICUNIT_ASSERT_NOT_EQUAL(shared, (void *)-1, shared);
+    ICUNIT_ASSERT_NOT_EQUAL(shared, reinterpret_cast<void *>(-1), shared);
 
     ret = shmdt(shared);
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_007.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_007.cpp
index 83e38df728395d98c9f03efc834bbd99ad4464b4..1f0e16d414db1294cb9318ac15d70521deb8facc 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_007.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_007.cpp
@@ -47,7 +47,7 @@ static int Testcase(void)
     ret = fork();
     if (ret == 0) {
         usleep(100000);
-        if ((shared = (char *)shmat(shmid, 0, 0)) == (void *)-1) {
+        if ((shared = static_cast<char *>(shmat(shmid, 0, 0))) == reinterpret_cast<void *>(-1)) {
             printf("child : error: shmat()\n");
             exit(1);
         }
@@ -72,8 +72,8 @@ static int Testcase(void)
         pid = ret;
         usleep(50000);
 
-        shared = (char *)shmat(shmid, 0, 0);
-        ICUNIT_ASSERT_NOT_EQUAL(shared, (void *)-1, shared);
+        shared = static_cast<char *>(shmat(shmid, 0, 0));
+        ICUNIT_ASSERT_NOT_EQUAL(shared, reinterpret_cast<void *>(-1), shared);
 
         ret = strncpy_s(shared, memSize, testStr, sizeof(testStr));
         ICUNIT_ASSERT_EQUAL(ret, 0, ret);
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_008.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_008.cpp
index 00bb3759d15bacc01adbd8f72a9b6b155736067f..7c8fb5f0c3cfccf9e4d2fdf25b2cc88f4adc6250 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_008.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_008.cpp
@@ -42,11 +42,11 @@ static int Testcase(void)
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     shared = shmat(shmid, 0, 0);
-    ICUNIT_ASSERT_EQUAL(shared, (void *)-1, shared);
+    ICUNIT_ASSERT_EQUAL(shared, reinterpret_cast<void *>(-1), shared);
     ICUNIT_ASSERT_EQUAL(errno, EACCES, errno);
 
     shared = shmat(shmid, 0, SHM_RDONLY);
-    ICUNIT_ASSERT_NOT_EQUAL(shared, (void *)-1, shared);
+    ICUNIT_ASSERT_NOT_EQUAL(shared, reinterpret_cast<void *>(-1), shared);
 
     ret = shmdt(shared);
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_009.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_009.cpp
index a8aeb1d0c05152109533c1ec9e6ccae54e359979..2fbb0854fd316e894d33285cdebf73df980ec873 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_009.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_009.cpp
@@ -88,14 +88,14 @@ static int Testcase(void)
     int ret;
     int pid;
 
-    void *ptr = (void *)signal(SIGTERM, ExitChildren);
+    void *ptr = reinterpret_cast<void *>(signal(SIGTERM, ExitChildren));
     ICUNIT_ASSERT_NOT_EQUAL(ptr, NULL, ptr);
 
     shmid = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0600);
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     g_shmptr = (int *)shmat(shmid, 0, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, (int *)-1, g_shmptr);
+    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, reinterpret_cast<int *>(-1), g_shmptr);
 
     *g_shmptr = 0;
 
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_013.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_013.cpp
index ba98058f5395ff52beadce6ad3b9b31555728966..773402aa5be0730b4fd22d0cd55e696c403e73ba 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_013.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_013.cpp
@@ -43,9 +43,9 @@ static int testcase(void)
     shmfd = shm_open("test_1", O_RDWR | O_CREAT | O_EXCL, 0644);
     ICUNIT_ASSERT_NOT_EQUAL(shmfd, -1, shmfd);
 
-    writebuf = (char*)malloc(pageSize);
+    writebuf = static_cast<char *>(malloc(pageSize));
     ICUNIT_ASSERT_NOT_EQUAL(writebuf, NULL, writebuf);
-    readbuf = (char*)malloc(pageSize);
+    readbuf = static_cast<char *>(malloc(pageSize));
     ICUNIT_GOTO_NOT_EQUAL(readbuf, NULL, readbuf, EXIT);
 
     (void)memset_s(writebuf, pageSize, 0xf, pageSize);
diff --git a/testsuites/unittest/basic/mem/shm/full/shm_test_014.cpp b/testsuites/unittest/basic/mem/shm/full/shm_test_014.cpp
index aee687848dfd856f66d050f42ba8b0233e1fff68..7acd2b7649bb606d033ad3a1be14d4d74aa9421c 100644
--- a/testsuites/unittest/basic/mem/shm/full/shm_test_014.cpp
+++ b/testsuites/unittest/basic/mem/shm/full/shm_test_014.cpp
@@ -49,9 +49,9 @@ static int testcase(void)
     
     shmfd = shm_open("test_2", O_RDONLY | O_CREAT, 00664);
     ICUNIT_ASSERT_NOT_EQUAL(shmfd, -1, shmfd);
-    writebuf = (char*)malloc(pageSize);
+    writebuf = static_cast<char *>(malloc(pageSize));
     ICUNIT_ASSERT_NOT_EQUAL(writebuf, NULL, writebuf);
-    readbuf = (char*)malloc(pageSize);
+    readbuf = static_cast<char *>(malloc(pageSize));
     ICUNIT_ASSERT_NOT_EQUAL(readbuf, NULL, readbuf);
     (void)memset_s(writebuf, pageSize, 0xf, pageSize);
 
diff --git a/testsuites/unittest/basic/mem/shm/smoke/shm_test_011.cpp b/testsuites/unittest/basic/mem/shm/smoke/shm_test_011.cpp
index 9f8e4865f87556f0aafba07b52778797d8c9cf6d..3a35156b664277c2d1735de1cdbde6db2f62be7e 100644
--- a/testsuites/unittest/basic/mem/shm/smoke/shm_test_011.cpp
+++ b/testsuites/unittest/basic/mem/shm/smoke/shm_test_011.cpp
@@ -45,7 +45,7 @@ static int Testcase(void)
     ret = fork();
     if (ret == 0) {
         shared = (int *)shmat(shmid, NULL, 0);
-        if (shared == (int *)-1) {
+        if (shared == reinterpret_cast<int *>(-1)) {
             exit(1);
         }
         *shared = 2;
@@ -55,7 +55,7 @@ static int Testcase(void)
     } else {
         usleep(20000);
         shared = (int *)shmat(shmid, NULL, 0);
-        ICUNIT_ASSERT_NOT_EQUAL(shared, (int *)-1, shared);
+        ICUNIT_ASSERT_NOT_EQUAL(shared, reinterpret_cast<int *>(-1), shared);
 
         ICUNIT_ASSERT_EQUAL(*shared, 2, *shared);
 
diff --git a/testsuites/unittest/basic/mem/vm/smoke/mmap_test_002.cpp b/testsuites/unittest/basic/mem/vm/smoke/mmap_test_002.cpp
index 8731e27ef80866d12d80ed870bf8f2ae25593788..85f44eed6b779bf2a7375a5ca38f20c767f75e2b 100644
--- a/testsuites/unittest/basic/mem/vm/smoke/mmap_test_002.cpp
+++ b/testsuites/unittest/basic/mem/vm/smoke/mmap_test_002.cpp
@@ -71,7 +71,7 @@ static int Testcase(void)
         printf("err: malloc size invalid\n");
         return -1;
     }
-    buf = (char *)malloc(pageSize);
+    buf = static_cast<char *>(malloc(pageSize));
     ICUNIT_ASSERT_NOT_EQUAL(buf, NULL, buf);
     (void)memset_s(buf, pageSize, 0xf, pageSize);
 
diff --git a/testsuites/unittest/basic/mem/vm/smoke/mmap_test_006.cpp b/testsuites/unittest/basic/mem/vm/smoke/mmap_test_006.cpp
index 4908d6140edc5136319f8860eb0c0e1592755f5b..6f45c8786bc77d6203249089a6bf86da9393cd39 100644
--- a/testsuites/unittest/basic/mem/vm/smoke/mmap_test_006.cpp
+++ b/testsuites/unittest/basic/mem/vm/smoke/mmap_test_006.cpp
@@ -49,7 +49,7 @@ static int Testcase(void)
     fd = open(file, O_CREAT | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO);
     ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
 
-    invalueAddr = (void *)(VALIDE_ADDR | ADDR_OFFSET);
+    invalueAddr = reinterpret_cast<void *>(VALIDE_ADDR | ADDR_OFFSET);
     mem = mmap(invalueAddr, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, fd, 0);
     ICUNIT_GOTO_EQUAL(mem, MAP_FAILED, mem, EXIT);
     ICUNIT_GOTO_EQUAL(errno, EINVAL, errno, EXIT);
diff --git a/testsuites/unittest/basic/mem/vm/smoke/user_copy_test_001.cpp b/testsuites/unittest/basic/mem/vm/smoke/user_copy_test_001.cpp
index f506db0b68b4b3acfe016dc157bb2afa8739b0ce..33c20f4c53cca974176d5d7f48fc9311cd9a9ba6 100644
--- a/testsuites/unittest/basic/mem/vm/smoke/user_copy_test_001.cpp
+++ b/testsuites/unittest/basic/mem/vm/smoke/user_copy_test_001.cpp
@@ -40,24 +40,26 @@ static int Testcase(void)
     const char *str = "Hi, OHOS.";
 
     /* sigprocmask 内核系统调用接口通过arch_copy_from_user拷贝用户参数 */
-    ret = sigprocmask(SIG_BLOCK, (sigset_t *)1, &oldset);
+    ret = sigprocmask(SIG_BLOCK, reinterpret_cast<sigset_t *>(1), &oldset);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(errno, EFAULT, errno);
 
-    ret = sigprocmask(SIG_BLOCK, (sigset_t *)INVALID_USER_VADDR, &oldset);
+    ret = sigprocmask(SIG_BLOCK, reinterpret_cast<sigset_t *>(INVALID_USER_VADDR), &oldset);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(errno, EFAULT, errno);
 
     /* sigprocmask 内核系统调用接口通过arch_copy_to_user将内核参数拷贝至用户 */
-    ret = sigprocmask(SIG_BLOCK, (sigset_t *)INVALID_USER_VADDR, (sigset_t *)1);
+    ret = sigprocmask(SIG_BLOCK, reinterpret_cast<sigset_t *>(INVALID_USER_VADDR), reinterpret_cast<sigset_t *>(1));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(errno, EFAULT, errno);
 
-    ret = sigprocmask(SIG_BLOCK, (sigset_t *)INVALID_USER_VADDR, (sigset_t *)INVALID_USER_VADDR);
+    ret = sigprocmask(SIG_BLOCK, reinterpret_cast<sigset_t *>(INVALID_USER_VADDR),
+                      reinterpret_cast<sigset_t *>(INVALID_USER_VADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(errno, EFAULT, errno);
 
-    ret = sigprocmask(SIG_BLOCK, (sigset_t *)INVALID_USER_VADDR, (sigset_t *)str);
+    ret = sigprocmask(SIG_BLOCK, reinterpret_cast<sigset_t *>(INVALID_USER_VADDR),
+                      reinterpret_cast<sigset_t *>(const_cast<char *>(str)));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(errno, EFAULT, errno);
 
diff --git a/testsuites/unittest/drivers/hid/smoke/hid_test_001.cpp b/testsuites/unittest/drivers/hid/smoke/hid_test_001.cpp
index 6057c3cae175f99dc5c061fb6cbdf5421bde8acb..8ddeb4f7c326ca581ddf53c2c25775b9331d0c29 100644
--- a/testsuites/unittest/drivers/hid/smoke/hid_test_001.cpp
+++ b/testsuites/unittest/drivers/hid/smoke/hid_test_001.cpp
@@ -53,7 +53,7 @@ static int Testcase(VOID)
         fd = open(MOUSE_DEV_PATH, O_RDWR, 0666);
         ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
 
-        buf = (char *)malloc(MOUSE_DATA_LEN);
+        buf = static_cast<char *>(malloc(MOUSE_DATA_LEN));
         ICUNIT_ASSERT_NOT_EQUAL(buf, NULL, buf);
         ret = memset_s(buf, MOUSE_DATA_LEN, 0, MOUSE_DATA_LEN);
         ICUNIT_ASSERT_EQUAL(ret, 0, ret);
diff --git a/testsuites/unittest/drivers/storage/smoke/storage_test_001.cpp b/testsuites/unittest/drivers/storage/smoke/storage_test_001.cpp
index 6b2ed769c790e89f3f4ae74b3634f333b1609168..62e48e1ef9b81545cee4d250cf10db0dcd0524ce 100644
--- a/testsuites/unittest/drivers/storage/smoke/storage_test_001.cpp
+++ b/testsuites/unittest/drivers/storage/smoke/storage_test_001.cpp
@@ -51,7 +51,7 @@ static int Testcase(VOID)
         fd = open(STORAGE_DEV_PATH, O_RDWR, 0666);
         ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
 
-        buf = (char *)malloc(STORAGE_DATA_LEN);
+        buf = static_cast<char *>(malloc(STORAGE_DATA_LEN));
         ICUNIT_ASSERT_NOT_EQUAL(buf, NULL, buf);
         ret = memset_s(buf, STORAGE_DATA_LEN, 0, STORAGE_DATA_LEN);
         ICUNIT_ASSERT_EQUAL(ret, 0, ret);
diff --git a/testsuites/unittest/extended/liteipc/smoke/liteipc_test_001.cpp b/testsuites/unittest/extended/liteipc/smoke/liteipc_test_001.cpp
index 658e68e9d88261b00a7ff3424feeab24533fb692..7355dc695bae24c58e3c9977e9ee7a239d1452ca 100644
--- a/testsuites/unittest/extended/liteipc/smoke/liteipc_test_001.cpp
+++ b/testsuites/unittest/extended/liteipc/smoke/liteipc_test_001.cpp
@@ -62,20 +62,20 @@ static int LiteIpcTest(void)
 
     /* testing mmap liteipc mem pool with different size and flag */
     retptr = mmap(nullptr, 1024 * 4096, PROT_READ, MAP_PRIVATE, fd, 0);
-    ICUNIT_ASSERT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
     //retptr = mmap(nullptr, 0, PROT_READ, MAP_PRIVATE, fd, 0);
     //ICUNIT_ASSERT_EQUAL((int)(intptr_t)retptr, -1, retptr);
     retptr = mmap(nullptr, -1, PROT_READ, MAP_PRIVATE, fd, 0);
-    ICUNIT_ASSERT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
     retptr = mmap(nullptr, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
-    ICUNIT_ASSERT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
     retptr = mmap(nullptr, 4096, PROT_READ, MAP_SHARED, fd, 0);
-    ICUNIT_ASSERT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
 
     retptr = mmap(nullptr, 1, PROT_READ, MAP_PRIVATE, fd, 0);
-    ICUNIT_ASSERT_NOT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_NOT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
     retptr = mmap(nullptr, 4095, PROT_READ, MAP_PRIVATE, fd, 0);
-    ICUNIT_ASSERT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
 
     /* testing read/write api */
     char buf[10] = {0};
@@ -121,7 +121,7 @@ static int TestCase(void)
     ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
 
     retptr = mmap(nullptr, 16 * 4096, PROT_READ, MAP_PRIVATE, fd, 0);
-    ICUNIT_ASSERT_NOT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_NOT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
     ret = ioctl(fd, IPC_SET_CMS, 0);
     ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
     ret = ioctl(fd, IPC_SET_CMS, 200);
diff --git a/testsuites/unittest/extended/liteipc/smoke/liteipc_test_002.cpp b/testsuites/unittest/extended/liteipc/smoke/liteipc_test_002.cpp
index ba8531d225195e316d5b6c12dc9d5054a2bb4027..0adbbe06f1d3ae793b190d121c75ec04aa823c8b 100644
--- a/testsuites/unittest/extended/liteipc/smoke/liteipc_test_002.cpp
+++ b/testsuites/unittest/extended/liteipc/smoke/liteipc_test_002.cpp
@@ -65,7 +65,7 @@ static int CallTestServiceLoop(uint32_t id)
     ret = GetService(g_ipcFd, g_serviceName, sizeof(g_serviceName), &serviceHandle);
     ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
     retptr = mmap(NULL, 4096, PROT_READ, MAP_PRIVATE, g_ipcFd, 0);
-    ICUNIT_ASSERT_NOT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_NOT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
     ret = GetService(g_ipcFd, g_serviceName, sizeof(g_serviceName), &serviceHandle);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
@@ -141,7 +141,7 @@ static int TestServiceLoop(void)
     ret = RegService(g_ipcFd, g_serviceName, sizeof(g_serviceName), &serviceHandle);
     ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
     retptr = mmap(NULL, 4096, PROT_READ, MAP_PRIVATE, g_ipcFd, 0);
-    ICUNIT_ASSERT_NOT_EQUAL((int)(intptr_t)retptr, -1, retptr);
+    ICUNIT_ASSERT_NOT_EQUAL(static_cast<int>(static_cast<intptr_t>(retptr)), -1, retptr);
     ret = RegService(g_ipcFd, g_serviceName, sizeof(g_serviceName), &serviceHandle);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
diff --git a/testsuites/unittest/extended/signal/full/It_ipc_pipe_002.cpp b/testsuites/unittest/extended/signal/full/It_ipc_pipe_002.cpp
index 58243b5227f4f853f0359be4eb6e2bb8ce15367e..02a4c5dd8b3063bd26a6a04808201beceee0a2f0 100644
--- a/testsuites/unittest/extended/signal/full/It_ipc_pipe_002.cpp
+++ b/testsuites/unittest/extended/signal/full/It_ipc_pipe_002.cpp
@@ -40,7 +40,7 @@ static UINT32 Testcase(VOID)
 
     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
+    shmid = shmget(static_cast<key_t>(IPC_PRIVATE), sizeof(int), 0666 | IPC_CREAT); // 0666 the authority of the shm
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
     sharedflag = (int *)shmat(shmid, NULL, 0);
     *sharedflag = 0;
diff --git a/testsuites/unittest/extended/signal/full/It_ipc_pipe_003.cpp b/testsuites/unittest/extended/signal/full/It_ipc_pipe_003.cpp
index e19417f8e564e212c6103d50694d7c1eed1493a7..c222e8652b714d353eb94aee34df19b231ec9613 100644
--- a/testsuites/unittest/extended/signal/full/It_ipc_pipe_003.cpp
+++ b/testsuites/unittest/extended/signal/full/It_ipc_pipe_003.cpp
@@ -42,7 +42,7 @@ static UINT32 Testcase(VOID)
 
     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
+    shmid = shmget(static_cast<key_t>(IPC_PRIVATE), sizeof(int), 0666 | IPC_CREAT); // 0666 the authority of the shm
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
     sharedflag = (int *)shmat(shmid, NULL, 0);
     *sharedflag = 0;
diff --git a/testsuites/unittest/extended/signal/full/pipe_test_005.cpp b/testsuites/unittest/extended/signal/full/pipe_test_005.cpp
index 9b490529dad9dbf7da2dd0c3e700ceb162ed23b5..720f9b6f067a966fd8070e0a4eba9bdfa5305774 100644
--- a/testsuites/unittest/extended/signal/full/pipe_test_005.cpp
+++ b/testsuites/unittest/extended/signal/full/pipe_test_005.cpp
@@ -56,7 +56,7 @@ static int PipecommonWrite()
         printf("signal error\n");
     }
 
-    shmid = shmget((key_t)IPC_PRIVATE, sizeof(int), 0666 | IPC_CREAT); // 0666 the authority of the shm
+    shmid = shmget(static_cast<key_t>(IPC_PRIVATE), sizeof(int), 0666 | IPC_CREAT); // 0666 the authority of the shm
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
     sharedflag = (int *)shmat(shmid, NULL, 0);
     *sharedflag = 0;
diff --git a/testsuites/unittest/extended/signal/full/signal_test_026.cpp b/testsuites/unittest/extended/signal/full/signal_test_026.cpp
index f555f2fd13888c826397f2209160fe5d8043ad6b..63293c6aafce44f697aa041246cd6f8a76e62f07 100644
--- a/testsuites/unittest/extended/signal/full/signal_test_026.cpp
+++ b/testsuites/unittest/extended/signal/full/signal_test_026.cpp
@@ -80,7 +80,7 @@ static UINT32 TestCase(VOID)
         sigaddset(&newset, SIGCHLD);
         timeout.tv_nsec = 1;
         timeout.tv_sec = 3; // 3, set the sec of timeout.
-        ret = sigtimedwait(&newset, (siginfo_t *)2, &timeout); // 2, wait for signal num
+        ret = sigtimedwait(&newset, reinterpret_cast<siginfo_t *>(2), &timeout); // 2, wait for signal num
         printf("ret = %d    errno = %d   EFAULT = %d\n", ret, errno, EFAULT);
         if (ret != -1) {
             exit(ret);
diff --git a/testsuites/unittest/extended/signal/full/signal_test_029.cpp b/testsuites/unittest/extended/signal/full/signal_test_029.cpp
index 45d7f5250abda0fdcba15a5848f6945aedc1e08f..c06e84bff99d54e873a466bd74d04ba5c3c694b8 100644
--- a/testsuites/unittest/extended/signal/full/signal_test_029.cpp
+++ b/testsuites/unittest/extended/signal/full/signal_test_029.cpp
@@ -73,7 +73,7 @@ static UINT32 TestCase(VOID)
             exit(errno);
         }
 
-        ret = sigsuspend((sigset_t *)2); // 2, suspend signal num.
+        ret = sigsuspend(reinterpret_cast<sigset_t *>(2)); // 2, suspend signal num.
         if (ret != -1) {
             exit(ret);
         }
@@ -89,7 +89,7 @@ static UINT32 TestCase(VOID)
             exit(errno);
         }
 
-        ret = sigpending((sigset_t *)2); // 2, pending signal num.
+        ret = sigpending(reinterpret_cast<sigset_t *>(2)); // 2, pending signal num.
         if (ret != -1) {
             exit(ret);
         }
diff --git a/testsuites/unittest/extended/signal/smoke/pipe_test_002.cpp b/testsuites/unittest/extended/signal/smoke/pipe_test_002.cpp
index c3de50008c777de7600db032d5ee3df53de92b8f..4a70518235b7c54fbdfa750e2b82e723583ea19f 100644
--- a/testsuites/unittest/extended/signal/smoke/pipe_test_002.cpp
+++ b/testsuites/unittest/extended/signal/smoke/pipe_test_002.cpp
@@ -51,7 +51,7 @@ static int TestPipeMultiProcess()
 
     int flag = fcntl(*readFd, F_GETFL);
     fcntl(*readFd, F_SETFL, flag | O_NONBLOCK);
-    shmid = shmget((key_t)IPC_PRIVATE, sizeof(int), 0666 | IPC_CREAT); // 0666 the authority of the shm
+    shmid = shmget(static_cast<key_t>(IPC_PRIVATE), sizeof(int), 0666 | IPC_CREAT); // 0666 the authority of the shm
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
     sharedflag = (int *)shmat(shmid, NULL, 0);
     *sharedflag = 0;
diff --git a/testsuites/unittest/extended/signal/smoke/signal_test_002.cpp b/testsuites/unittest/extended/signal/smoke/signal_test_002.cpp
index 43018ae5b33c8f7554f5fcbf38d2a749f4610714..540b02a66fafd1b4cd0233a16f256625ce5c6adf 100644
--- a/testsuites/unittest/extended/signal/smoke/signal_test_002.cpp
+++ b/testsuites/unittest/extended/signal/smoke/signal_test_002.cpp
@@ -47,7 +47,7 @@ static int TestRaiseIgnore(void)
 
     g_sigCount = 0;
     // trigger one
-    ret = (void *)signal(sig, SigPrint);
+    ret = reinterpret_cast<void *>(signal(sig, SigPrint));
     ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret);
 
     retValue = raise(sig);
@@ -55,13 +55,13 @@ static int TestRaiseIgnore(void)
 
     usleep(1000); // 1000, Used to calculate the delay time.
     // trigger ignore
-    ret = (void *)signal(sig, SIG_IGN);
+    ret = reinterpret_cast<void *>(signal(sig, SIG_IGN));
     ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret);
 
     retValue = raise(sig);
     ICUNIT_ASSERT_EQUAL(retValue, 0, retValue);
     // trigger one
-    ret = (void *)signal(sig, SigPrint);
+    ret = reinterpret_cast<void *>(signal(sig, SigPrint));
     ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret);
     retValue = raise(sig);
     ICUNIT_ASSERT_EQUAL(retValue, 0, retValue);
diff --git a/testsuites/unittest/extended/signal/smoke/signal_test_013.cpp b/testsuites/unittest/extended/signal/smoke/signal_test_013.cpp
index 6ccd38029d7cd9bdfda0b460f4d12ea64cb26110..040fcfffda5e61b07217591419546fe9c42f8888 100644
--- a/testsuites/unittest/extended/signal/smoke/signal_test_013.cpp
+++ b/testsuites/unittest/extended/signal/smoke/signal_test_013.cpp
@@ -63,8 +63,8 @@ static void *ThreadSetFunc2(void *arg)
     pthread_exit((void *)NULL);
     return NULL;
 EXIT:
-    pthread_exit((void *)-1);
-    return (void *)-1;
+    pthread_exit(reinterpret_cast<void *>(-1));
+    return reinterpret_cast<void *>(-1);
 }
 
 static void *ThreadSetDfl(void *arg)
@@ -76,8 +76,8 @@ static void *ThreadSetDfl(void *arg)
     pthread_exit((void *)NULL);
     return NULL;
 EXIT:
-    pthread_exit((void *)-1);
-    return (void *)-1;
+    pthread_exit(reinterpret_cast<void *>(-1));
+    return reinterpret_cast<void *>(-1);
 }
 
 static void *ThreadKill(void *arg)
@@ -90,8 +90,8 @@ static void *ThreadKill(void *arg)
     pthread_exit((void *)NULL);
     return NULL;
 EXIT:
-    pthread_exit((void *)-1);
-    return (void *)-1;
+    pthread_exit(reinterpret_cast<void *>(-1));
+    return reinterpret_cast<void *>(-1);
 }
 
 static int TestSigMultiPthread(void)
@@ -119,15 +119,15 @@ static int TestSigMultiPthread(void)
             exit(ret);
         }
 
-        pthread_join(thread, (void **)&status1);
+        pthread_join(thread, reinterpret_cast<void **>(&status1));
         if ((int)(intptr_t)status1 != 0) {
             exit(-1);
         }
-        pthread_join(thread1, (void **)&status1);
+        pthread_join(thread1, reinterpret_cast<void **>(&status1));
         if ((int)(intptr_t)status1 != 0) {
             exit(-1);
         }
-        pthread_join(thread2, (void **)&status1);
+        pthread_join(thread2, reinterpret_cast<void **>(&status1));
         if ((int)(intptr_t)status1 != 0) {
             exit(-1);
         }
diff --git a/testsuites/unittest/extended/signal/smoke/signal_test_037.cpp b/testsuites/unittest/extended/signal/smoke/signal_test_037.cpp
index e26054763f94261fa2e4999fe1b9b87cdf35ab72..75f8c4bd21fde9432defaf9616e48f3d13563b2d 100644
--- a/testsuites/unittest/extended/signal/smoke/signal_test_037.cpp
+++ b/testsuites/unittest/extended/signal/smoke/signal_test_037.cpp
@@ -49,7 +49,7 @@ static UINT32 TestCase(VOID)
         ICUNIT_ASSERT_EQUAL(retval, -1, retval);
         ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
         printf("----------------------------------\n");
-        retval = sigprocmask(SIG_BLOCK, (sigset_t *)1, &oldset);
+        retval = sigprocmask(SIG_BLOCK, reinterpret_cast<sigset_t *>(1), &oldset);
         ICUNIT_ASSERT_EQUAL(retval, -1, retval);
         ICUNIT_ASSERT_EQUAL(errno, EFAULT, errno);
         printf("----------------------------------\n");
diff --git a/testsuites/unittest/extended/trace/smoke/trace_test_004.cpp b/testsuites/unittest/extended/trace/smoke/trace_test_004.cpp
index 2ec18090e535b6b905365dd7a61c05b16f0e3880..513624cc28ce206170f1b6b0dc6ffc52aeedf990 100644
--- a/testsuites/unittest/extended/trace/smoke/trace_test_004.cpp
+++ b/testsuites/unittest/extended/trace/smoke/trace_test_004.cpp
@@ -43,7 +43,7 @@ static UINT32 TestCase(VOID)
 
     ioctl(fd, TRACE_STOP, NULL);
 
-    buffer= (char *)malloc(size);
+    buffer = (char *)malloc(size);
     if (buffer == NULL) {
         printf("Read buffer malloc failed!\n");
         goto EXIT;
diff --git a/testsuites/unittest/libc/io/full/IO_test_duplocale_001.cpp b/testsuites/unittest/libc/io/full/IO_test_duplocale_001.cpp
index a75d39e491559935b6eebbb9264bf21036437f13..442cf09ca467973c34f71e05ec82773623c25c2b 100644
--- a/testsuites/unittest/libc/io/full/IO_test_duplocale_001.cpp
+++ b/testsuites/unittest/libc/io/full/IO_test_duplocale_001.cpp
@@ -118,7 +118,7 @@ static UINT32 testcase(VOID)
     locale_t newloc = nullptr;
 
     char *pathList[] = {"/storage/zh_CN.UTF-8"};
-    char *streamList[] = {(char *)fileWords};
+    char *streamList[] = {reinterpret_cast<char *>(fileWords)};
     int streamLen[] = {sizeof(fileWords) - 2};
 
     newloc = duplocale(oldloc);
diff --git a/testsuites/unittest/libc/io/full/IO_test_nl_langinfo_l_001.cpp b/testsuites/unittest/libc/io/full/IO_test_nl_langinfo_l_001.cpp
index 922e0c188fa0a907af397222604b554be5e91946..a7c3571088e54c28b942240e19686ccf08676354 100644
--- a/testsuites/unittest/libc/io/full/IO_test_nl_langinfo_l_001.cpp
+++ b/testsuites/unittest/libc/io/full/IO_test_nl_langinfo_l_001.cpp
@@ -41,8 +41,8 @@ static UINT32 testcase(VOID) {
     setlocale(LC_NUMERIC, "");
 
     /* echo the nl_langinfo_l */
-    printf("%s\n", nl_langinfo_l(CODESET, (locale_t)"en_US.UTF-8"));
-    printf("%s\n", nl_langinfo_l(RADIXCHAR, (locale_t)"en_US.UTF-8"));
+    printf("%s\n", nl_langinfo_l(CODESET, reinterpret_cast<locale_t>(const_cast<char *>("en_US.UTF-8"))));
+    printf("%s\n", nl_langinfo_l(RADIXCHAR, reinterpret_cast<locale_t>(const_cast<char *>("en_US.UTF-8"))));
 
     /* set the locale info */
     setenv("MUSL_LOCPATH", "/storage", 1);
@@ -53,10 +53,10 @@ static UINT32 testcase(VOID) {
     setlocale(LC_NUMERIC, "");
 
     /* echo the nl_langinfo */
-    printf("%s\n", nl_langinfo_l(CODESET, (locale_t)"zh_CN.UTF-8"));
-    printf("%s\n", nl_langinfo_l(RADIXCHAR, (locale_t)"zh_CN.UTF-8"));
+    printf("%s\n", nl_langinfo_l(CODESET, reinterpret_cast<locale_t>(const_cast<char *>("zh_CN.UTF-8"))));
+    printf("%s\n", nl_langinfo_l(RADIXCHAR, reinterpret_cast<locale_t>(const_cast<char *>("zh_CN.UTF-8"))));
 
-    char *string = nl_langinfo_l(CRNCYSTR, (locale_t)"zh_CN.UTF-8");
+    char *string = nl_langinfo_l(CRNCYSTR, reinterpret_cast<locale_t>(const_cast<char *>("zh_CN.UTF-8")));
     ICUNIT_ASSERT_NOT_EQUAL_NULL(string, NULL, string);
     setlocale(LC_ALL, "C");
 
diff --git a/testsuites/unittest/libc/io/full/It_stdio_hasmntopt_001.cpp b/testsuites/unittest/libc/io/full/It_stdio_hasmntopt_001.cpp
index 151a7b4b9027c57b6b31dba03590407b41da2a6a..904b58534e829eec34d2f2b8da97d6febe54c028 100644
--- a/testsuites/unittest/libc/io/full/It_stdio_hasmntopt_001.cpp
+++ b/testsuites/unittest/libc/io/full/It_stdio_hasmntopt_001.cpp
@@ -44,7 +44,7 @@ static UINT32 testcase(VOID)
 
     char fileWords[] = "/dev/disk/by-uuid/c4992556-a86e-45e8-ba5f-190b16a9073x /usr1 ext3 errors=remount-ro,nofail 0 1";
     char *pathList[] = {"/etc/fstab"};
-    char *streamList[] = {(char *)fileWords};
+    char *streamList[] = {static_cast<char *>(fileWords)};
     int streamLen[] = {sizeof(fileWords)};
 
     int flag = PrepareFileEnv(pathList, streamList, streamLen, 1);
diff --git a/testsuites/unittest/libc/misc/full/misc_test_006.cpp b/testsuites/unittest/libc/misc/full/misc_test_006.cpp
index 616edf51ac5e543e6ac2ec515d6f2f58fc6b3530..12241e4fec49483af3f3886f7da54599c944de89 100644
--- a/testsuites/unittest/libc/misc/full/misc_test_006.cpp
+++ b/testsuites/unittest/libc/misc/full/misc_test_006.cpp
@@ -31,9 +31,9 @@
 #include "It_test_misc.h"
 #include "sys/utsname.h"
 
-#define INVALID_ADDR_FIRST_PAGE ((struct utsname *)0x1200000)
-#define INVALID_ADDR_USER_ADDR ((struct utsname *)0x1000000)
-#define INVALID_ADDR_KERNEL_READONLY_ADDR ((struct utsname *)0x4016c75c)
+#define INVALID_ADDR_FIRST_PAGE (reinterpret_cast<struct utsname *>(0x1200000))
+#define INVALID_ADDR_USER_ADDR (reinterpret_cast<struct utsname *>(0x1000000))
+#define INVALID_ADDR_KERNEL_READONLY_ADDR (reinterpret_cast<struct utsname *>(0x4016c75c))
 
 static UINT32 TestCase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_145.cpp b/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_145.cpp
index feed4ff34780aee277dd1425c09ff6097d31a653..704fd347c4b9b7ab501136b7d5c83a65e17da5ec 100644
--- a/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_145.cpp
+++ b/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_145.cpp
@@ -43,11 +43,11 @@ static VOID *PthreadF01(VOID *mq)
 
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     g_testCount = 0;
     return NULL;
 }
@@ -64,11 +64,11 @@ static VOID *PthreadF02(VOID *mq)
     }
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     g_testCount = 0;
     return NULL;
 }
@@ -85,11 +85,11 @@ static VOID *PthreadF03(VOID *mq)
     }
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     g_testCount = 0;
     return NULL;
 }
@@ -107,11 +107,11 @@ static VOID *PthreadF04(VOID *mq)
 
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     g_testCount = 0;
     return NULL;
 }
diff --git a/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_146.cpp b/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_146.cpp
index 35f58de5cf970ab052fc6b4b85f79aff3aa32b8c..e075f335ac428a3e5306bff478b758ed0ba92c47 100644
--- a/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_146.cpp
+++ b/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_146.cpp
@@ -50,11 +50,11 @@ static VOID *PthreadF01(VOID *info)
 
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     g_testCount = 0;
     return NULL;
 }
@@ -74,11 +74,11 @@ static VOID *PthreadF02(VOID *info)
 
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     g_testCount = 0;
     return NULL;
 }
diff --git a/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_162.cpp b/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_162.cpp
index e4f81df38be3398b77ae573887e42c0f5741161f..74a5128d32da893c06f443f3b23e16ed8ba601db 100644
--- a/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_162.cpp
+++ b/testsuites/unittest/libc/posix/mqueue/full/It_posix_queue_162.cpp
@@ -41,11 +41,11 @@ static VOID *PthreadF01(VOID *arg)
     }
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     g_testCount = 0;
     return NULL;
 }
@@ -63,12 +63,12 @@ static VOID *PthreadF02(VOID *arg)
 
     LOS_AtomicInc(&g_testCount);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
 
     return NULL;
 EXIT:
     g_testCount = 0;
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     return NULL;
 }
 
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_010.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_010.cpp
index 3811c72e0b7193a27dad024f3225c2e174ee79a8..bad032478ab9076dff18b2e46c1de41bfab566c0 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_010.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_010.cpp
@@ -34,9 +34,9 @@ static VOID *pthread_f01(void *argument)
 {
     g_testCount = pthread_self();
 
-    pthread_exit((void *)8);
+    pthread_exit(static_cast<void *>(8)); // 8: exit value for testing
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_023.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_023.cpp
index 3e70982daf8a190d040c1eb53b8a19a4faad10b6..b511ab00423b1e7b9c5f4ced29008ed7b47dda13 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_023.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_023.cpp
@@ -42,12 +42,13 @@ static VOID *pthread_f01(void *argument)
 {
     g_testCount++;
 
-    pthread_cleanup_push(PthreadCleanF01, (void *)8);
-    if (argument)
-        return (void *)8;
+    pthread_cleanup_push(PthreadCleanF01, static_cast<void *>(8)); // 8:arg that routine is called with
+    if (argument) {
+        return static_cast<void *>(8); // 8: return value for testing if argument is not NULL
+    }
     pthread_cleanup_pop(0);
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_025.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_025.cpp
index 64e0a318a92453632644832c0eb73c807fcce8a2..d95411ece98935404b66c2038aaf5c248bbe7959 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_025.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_025.cpp
@@ -42,11 +42,11 @@ static VOID *pthread_f01(void *argument)
 {
     g_testCount++;
 
-    pthread_cleanup_push(PthreadCleanF01, (void *)8);
-    pthread_exit((void *)8);
+    pthread_cleanup_push(PthreadCleanF01, static_cast<void *>(8)); // 8: arg that routine is called with
+    pthread_exit(static_cast<void *>(8)); // 8: exit value for testing
     pthread_cleanup_pop(1);
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_026.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_026.cpp
index 82e204dbd65b8c4c5d6a6ae1b64ba0393223c5c6..d697f00eeb51ae661a539df15f0d5d7aebae45ed 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_026.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_026.cpp
@@ -43,11 +43,11 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
     LosTaskDelay(5);
 
-    pthread_cleanup_push(PthreadCleanF01, (void *)8);
+    pthread_cleanup_push(PthreadCleanF01, static_cast<void *>(8)); // 8: arg that routine is called with
     pthread_testcancel();
     pthread_cleanup_pop(1);
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_027.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_027.cpp
index 45c12c168101fa83464f29d47adc683425987bf7..672af91577df6e447264e9a050e32cc3ed2f3fe3 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_027.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_027.cpp
@@ -46,13 +46,13 @@ static VOID *pthread_f01(void *argument)
 {
     g_testCount++;
 
-    pthread_cleanup_push(PthreadCleanF01, (void *)9);
-    pthread_cleanup_push(PthreadCleanF01, (void *)8);
-    pthread_exit((void *)8);
+    pthread_cleanup_push(PthreadCleanF01, static_cast<void *>(9)); // 9: arg that routine is called with
+    pthread_cleanup_push(PthreadCleanF01, static_cast<void *>(8)); // 8: arg that routine is called with
+    pthread_exit(static_cast<void *>(8)); // 8: exit value for testing
     pthread_cleanup_pop(1);
     pthread_cleanup_pop(1);
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_028.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_028.cpp
index 5a7a5363d5d874f69da12583f7dc334eec63ae65..ec9d9b20dba4c4d267110cb2e2bbd948154fc279 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_028.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_028.cpp
@@ -34,7 +34,7 @@ static VOID *pthread_f01(void *argument)
 {
     g_testCount++;
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_029.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_029.cpp
index bfebb8df6ade007741dd5c68b316120c97f2a2b2..fa868f16f047de30d283871dd128eef31e58e28b 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_029.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_029.cpp
@@ -34,8 +34,8 @@ static VOID *pthread_f01(void *argument)
 {
     g_testCount++;
 
-    pthread_exit((void *)8);
-    return (void *)9;
+    pthread_exit(static_cast<void *>(8)); // 8: exit value for testing
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_030.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_030.cpp
index 6d7e9153c837cde7752e8a2a00397f5a5af12352..e068b11a10cb683edfb2cc888c248ca18b496dd0 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_030.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_030.cpp
@@ -37,7 +37,7 @@ static VOID *pthread_f01(void *argument)
 
     pthread_testcancel();
     g_testCount++;
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_031.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_031.cpp
index 45523f265ab653160651cd312300454017899cdf..bed89e0c073b184fc1a53cd9760f507fb54dab18 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_031.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_031.cpp
@@ -39,7 +39,7 @@ static VOID *pthread_f01(void *argument)
     ret = pthread_join(g_newTh, NULL);
     ICUNIT_GOTO_NOT_EQUAL(ret, 0, ret, EXIT);
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_034.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_034.cpp
index c3596f479710e4a79e14ef8c1c11dd78852c6c74..4715817dba1b43ea30382194ca4e22818aa65f4c 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_034.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_034.cpp
@@ -43,7 +43,7 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
     ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f02(void *argument)
@@ -59,7 +59,7 @@ static VOID *pthread_f02(void *argument)
     g_testCount++;
     ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT);
 EXIT:
-    return (void *)8;
+    return static_cast<void *>(8); // 8: return value for testing
 }
 
 static VOID *PthreadF03(void *argument)
@@ -76,7 +76,7 @@ static VOID *PthreadF03(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT);
 
 EXIT:
-    return (void *)7;
+    return static_cast<void *>(7); // 7: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_035.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_035.cpp
index 8f7c8b62d171010ef8fb3f29a0058fb0d4d1a9f3..0269a7a668ed1ec74ce6ff842335c5120467370d 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_035.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_035.cpp
@@ -47,7 +47,7 @@ static VOID *pthread_f01(void *argument)
     g_testCnt1++;
     ICUNIT_GOTO_EQUAL(g_testCnt1, 4, g_testCnt1, EXIT);
 EXIT:
-    return (void *)9;
+    return reinterpret_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f02(void *argument)
@@ -67,7 +67,7 @@ static VOID *pthread_f02(void *argument)
     g_testCnt1++;
     ICUNIT_GOTO_EQUAL(g_testCnt1, 5, g_testCnt1, EXIT);
 EXIT:
-    return (void *)8;
+    return reinterpret_cast<void *>(8); // 8:return value for testing
 }
 
 static VOID *PthreadF03(void *argument)
@@ -88,7 +88,7 @@ static VOID *PthreadF03(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCnt1, 6, g_testCnt1, EXIT);
 
 EXIT:
-    return (void *)7;
+    return reinterpret_cast<void *>(7); // 7: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
@@ -108,8 +108,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh3, NULL, PthreadF03, NULL);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    while (g_testCnt1 < 6)
+    while (g_testCnt1 < 6) { // 6: threshold for calling sleep
         sleep(1);
+    }
 
     ICUNIT_ASSERT_EQUAL(g_testCnt1, 6, g_testCnt1);
 
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_039.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_039.cpp
index 1acba6f011e58a6ac26eccab9e0768a0568eb177..82b9d593138d089fc06206e127185940631f1bab 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_039.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_039.cpp
@@ -36,7 +36,7 @@ static VOID *PthreadF01(void *argument)
     LosTaskDelay(2);
     pthread_testcancel();
     g_testCount++;
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_040.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_040.cpp
index 1da332effea36c561b991f7a4b92b2a36b2d4e0f..55ee8bc0006dc39ef5cc37858005d6c39cfa571a 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_040.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_040.cpp
@@ -36,7 +36,7 @@ static VOID *pthread_f01(void *argument)
     LosTaskDelay(2);
     g_testCount++;
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_042.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_042.cpp
index 1191d6d57c4c5e50c0e3cb44938d7a4c5e0ce7fd..08aa7c36200702d25f5ee08b6aaec017e62dfa77 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_042.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_042.cpp
@@ -36,7 +36,7 @@ static VOID *pthread_f01(void *argument)
     LosTaskDelay(2);
     g_testCount++;
 
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_044.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_044.cpp
index 35e76fe09eeaacd301c19ee80f418a0e0da5abe2..420b723dd634d026b09f4b04e4c61ae30e7dac95 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_044.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_044.cpp
@@ -47,7 +47,7 @@ static VOID *pthread_f02(void *argument)
     ICUNIT_GOTO_EQUAL(param.sched_priority, 3, param.sched_priority, EXIT);
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f01(void *argument)
@@ -89,7 +89,7 @@ static VOID *pthread_f01(void *argument)
     ret = pthread_attr_destroy(&attr);
     ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_045.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_045.cpp
index beed44062b1f4c53fc029d689d64b493e86a057e..f6a32df4ac6ca1ee11771369ab0ea0e3fd729f9e 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_045.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_045.cpp
@@ -39,7 +39,7 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_046.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_046.cpp
index 775c3061cda24c112f98647e69924a3adc5ac108..06998e72d236a8f3c121d7e21e341bb750faaef9 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_046.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_046.cpp
@@ -37,7 +37,7 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_051.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_051.cpp
index 106beb1836037265d9acdd781efa8d8e9d8b94ee..97a9c0c34b37e7a112888c23cf6dbae1c3937889 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_051.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_051.cpp
@@ -49,7 +49,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // not reachable
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_052.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_052.cpp
index 29edfdc8795e8e9d0e089c369ab4b099eb60b85d..580564f7888e43413a36e945e14431862dfefa95 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_052.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_052.cpp
@@ -53,7 +53,7 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
     ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT);
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f02(void *argument)
@@ -79,7 +79,7 @@ static VOID *pthread_f02(void *argument)
     g_testCount++;
     ICUNIT_GOTO_EQUAL(g_testCount, 6, g_testCount, EXIT);
 EXIT:
-    return (void *)8;
+    return static_cast<void *>(8); // 8: return value for testing
 }
 
 static VOID *PthreadF03(void *argument)
@@ -107,7 +107,7 @@ static VOID *PthreadF03(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 8, g_testCount, EXIT);
 
 EXIT:
-    return (void *)7;
+    return static_cast<void *>(7); // 7: return value for testing
 }
 
 static void PthreadKeyF01(void *threadLog)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_053.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_053.cpp
index 4ab4aed4d302df66744439293820cca15a71b4e5..deef91748829f2dcf3d1f7fd9905b0b043d4a108 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_053.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_053.cpp
@@ -71,7 +71,7 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
     ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT);
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f02(void *argument)
@@ -115,7 +115,7 @@ static VOID *pthread_f02(void *argument)
     g_testCount++;
     ICUNIT_GOTO_EQUAL(g_testCount, 7, g_testCount, EXIT);
 EXIT:
-    return (void *)8;
+    return static_cast<void *>(8); // 8: return value for testing
 }
 static void PthreadKeyF01(void *threadLog)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_054.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_054.cpp
index 7d3a39e9eb3d1b4e831c6abe868d9c9f9e06071a..0c202abe95a6dbc6d042fc459f0d5cdc857dab32 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_054.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_054.cpp
@@ -49,9 +49,9 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
     ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT);
 
-    pthread_exit((void *)7);
+    pthread_exit(static_cast<void *>(7)); // 7: exit value for testing
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static void PthreadKeyF01(void *threadLog)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_055.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_055.cpp
index 2302bb08870af130694ae22b7d1eb92ab8dbe740..a0c9e68b46e88c87b6b11f21e0d10e67141d8d5f 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_055.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_055.cpp
@@ -51,7 +51,7 @@ static VOID *pthread_f01(void *argument)
 
     pthread_testcancel();
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static void PthreadKeyF01(void *threadLog)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_059.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_059.cpp
index 925c3f100362ca0b7f13a207a6fce67fbab0439f..354be5ade8f9c1dab98176d7951863e08d8a906e 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_059.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_059.cpp
@@ -41,7 +41,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // failed, =2
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_060.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_060.cpp
index 4a4e8f6e3b95cf8d711f7b3748d637bb8f9e6706..d55ad834f0aeda61c57775f3807a6816c36e796e 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_060.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_060.cpp
@@ -33,7 +33,7 @@
 static VOID *pthread_f02(void *argument)
 {
     g_testCount++;
-    return (void *)8;
+    return static_cast<void *>(8); // 8: return value for testing
 }
 static VOID *pthread_f01(void *argument)
 {
@@ -54,7 +54,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_061.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_061.cpp
index 2a3aa5d87169a3b3dbab62e60bd6b98c8fbfc5b3..9d4d3626ea44968474655dfeff63a8b4a2e2bfbb 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_061.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_061.cpp
@@ -50,7 +50,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_062.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_062.cpp
index af3e0f6acc9a7411ab8154f9ea9afcc76ab5a140..db359dff5e5bd7584594ca5c8a67a34564983aa5 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_062.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_062.cpp
@@ -45,7 +45,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_063.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_063.cpp
index 75be1055f820e9a16ca6f052d6a26e7e6f7d0078..25126319c02bdc1811b5efef5f38e802c35739be 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_063.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_063.cpp
@@ -51,7 +51,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 0, g_testCount, EXIT);
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_064.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_064.cpp
index 881e3380597a194d133e4a17751bbd50944ee8fd..b9a7154c6d1e4a595cb6637f0501a4d9375e0199 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_064.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_064.cpp
@@ -52,7 +52,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT);
 
 EXIT:
-    return (void *)9;
+    return reinterpret_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_066.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_066.cpp
index 193faba33c7c5bec6b8a28d854a9975c21287a2b..3682f508b57ef07eb5753d2cfb7f08a66a52541f 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_066.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_066.cpp
@@ -44,7 +44,7 @@ static VOID *pthread_f02(void *argument)
 
     ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT);
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f01(void *argument)
@@ -86,7 +86,7 @@ static VOID *pthread_f01(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT);
 #endif
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_080.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_080.cpp
index e350881de1d566d666bd1b2690a19034f344404c..89e876c315b3b12c02a74b0e34f826d3ca53524f 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_080.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_080.cpp
@@ -69,8 +69,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(1000 * 10 * 2);
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_081.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_081.cpp
index eda2a34f69690ee46cfec3ad4617fd39551eef59..e25b699f09e6d9c8a4fd225c5097f2a026aa7180 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_081.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_081.cpp
@@ -74,8 +74,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(1000 * 10 * 2);
+    }
     /*
      * Acquire the mutex to make sure that all waiters are currently
      * blocked on pthread_cond_wait
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_082.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_082.cpp
index 9cd04309517a5c1207ca378ae0233c69bfa75f33..80d08c518750090c2400ae5a439f1bce3cd677f4 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_082.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_082.cpp
@@ -81,8 +81,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(1000 * 10 * 2);
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_083.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_083.cpp
index 6e5fd3c65124a917a018aab45b69fe8eb11bc635..f1fba762a20caaa6dbb0836e7d256f92c419fc1f 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_083.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_083.cpp
@@ -70,8 +70,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(1000 * 10 * 2);
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_084.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_084.cpp
index b8058e233245b913322c74bac32697b8716bfcdf..2fdb5a9868a31b3fe0c0ae7db4c587431612a2ac 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_084.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_084.cpp
@@ -73,8 +73,9 @@ static UINT32 Testcase(VOID)
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    while (g_startNum < THREAD_NUM)
+    while (g_startNum < THREAD_NUM) {
         usleep(1000 * 10 * 2);
+    }
 
     /*
      * Acquire the mutex to make sure that all waiters are currently
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_085.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_085.cpp
index 83962c1526acd82132985fe3f292059aa3df929d..9ea914576979572ee85dad19b07a24785554dde6 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_085.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_085.cpp
@@ -68,8 +68,9 @@ static UINT32 Testcase(VOID)
     rc = pthread_create(&thread1, NULL, pthread_f01, NULL);
     ICUNIT_ASSERT_EQUAL(rc, 0, rc);
 
-    while (!g_t1Start) /* wait for thread1 started */
+    while (!g_t1Start) { /* wait for thread1 started */
         usleep(1000 * 10 * 2);
+    }
 
     /* acquire the mutex released by pthread_cond_wait() within thread 1 */
     rc = pthread_mutex_lock(&g_td.mutex);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_087.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_087.cpp
index 0cf58da46c7a890a507d84b7709b2c4a16e665ff..40c0e3901ddd33d49888a2f4bc9f1e256e800644 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_087.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_087.cpp
@@ -57,7 +57,7 @@ static void *pthread_f01(void *arg)
     rc = pthread_mutex_unlock(&g_td.mutex);
     ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
 EXIT:
-    pthread_exit((void *)5);
+    pthread_exit(static_cast<void *>(5)); // 5: return value for testing
 }
 
 static UINT32 Testcase(VOID)
@@ -78,9 +78,9 @@ static UINT32 Testcase(VOID)
     rc = pthread_create(&thread1, NULL, pthread_f01, NULL);
     ICUNIT_ASSERT_EQUAL(rc, 0, rc);
 
-    while (!g_t1Start) /* wait for thread1 started */
+    while (!g_t1Start) { /* wait for thread1 started */
         usleep(1000 * 10 * 2);
-
+    }
 
     /* acquire the mutex released by pthread_cond_wait() within thread 1 */
     rc = pthread_mutex_lock(&g_td.mutex);
@@ -92,7 +92,7 @@ static UINT32 Testcase(VOID)
     g_signaled = 1;
     rc = pthread_join(thread1, &thRet);
     ICUNIT_ASSERT_EQUAL(rc, 0, rc);
-    ICUNIT_ASSERT_EQUAL((long)thRet, 5, (long)thRet);
+    ICUNIT_ASSERT_EQUAL(static_cast<long>(thRet), 5, static_cast<long>(thRet)); // 5: return value for testing
     g_signaled = 0;
 
     rc = pthread_cond_destroy(&g_td.cond);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_088.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_088.cpp
index 7b04f642358bea7f9d0b99134bc2dffe6af70ddb..875f7a64a167a4560ea7a447ae7e2a791d683d84 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_088.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_088.cpp
@@ -108,8 +108,9 @@ static void *pthread_f02(void *tmp)
     clock_gettime(CLOCK_REALTIME, &startTime);
     while (1) {
         clock_gettime(CLOCK_REALTIME, &currentTime);
-        if (PthreadTimeF01(currentTime, startTime) > RUNTIME)
+        if (PthreadTimeF01(currentTime, startTime) > RUNTIME) {
             break;
+        }
     }
     g_lowDone = 1;
 EXIT:
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_089.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_089.cpp
index ef7cf0448206eb7a4bc9dc1891d9e6100822b479..f0714dc93828b0bdefab164e5d8f4aad673dcf5f 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_089.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_089.cpp
@@ -111,8 +111,9 @@ static void *pthread_f02(void *tmp)
     clock_gettime(CLOCK_REALTIME, &startTime);
     while (1) {
         clock_gettime(CLOCK_REALTIME, &currentTime);
-        if (PthreadTimeF01(currentTime, startTime) > RUNTIME)
+        if (PthreadTimeF01(currentTime, startTime) > RUNTIME) {
             break;
+        }
     }
     g_lowDone = 1;
 EXIT:
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_090.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_090.cpp
index e65fa95124dfc9c9bb731cdebb00043a194e5a7f..645d4e325d761e9b04e281608788c33b0fe97416 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_090.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_090.cpp
@@ -40,8 +40,9 @@ static void *pthread_f01(void *arg)
     ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
 
     g_startNum++;
-    if (g_startNum > 5)
+    if (g_startNum > 5) { // 5: threshold for calling usleep
         usleep(1000 * 10 * 2);
+    }
 
     printf("pthread start_num: %d \n", g_startNum);
     rc = pthread_cond_wait(&g_td.cond, &g_td.mutex);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_091.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_091.cpp
index c648c05f46f15aff9959f400fd9c44e2f25a8e70..477509bcfde64c3579689f346849e5f112207c84 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_091.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_091.cpp
@@ -48,7 +48,7 @@ static VOID *pthread_f01(void *argument)
 
     ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
 EXIT:
-    return (void *)9;
+    return reinterpret_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f02(void *argument)
@@ -72,7 +72,7 @@ static VOID *pthread_f02(void *argument)
     printf("11\n");
     ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // failed , =3
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 static UINT32 Testcase(VOID)
 {
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_092.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_092.cpp
index b1e0f69b0216ea9f46f9a1fc82aa5534ee06ebb6..5f22c11d2f18cee7944bc6ad9f7abc14934c6289 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_092.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_092.cpp
@@ -42,8 +42,9 @@ static void *pthread_f01(void *arg)
     ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
 
     g_startNum++;
-    if (g_startNum > 5)
+    if (g_startNum > 5) { // 5: threshold for calling usleep
         usleep(1000 * 10 * 2);
+    }
 
     printf("pthread start_num: %d \n", g_startNum);
     rc = pthread_cond_wait(&g_td.cond, &g_td.mutex);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_094.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_094.cpp
index b49d38708a83bf75bfbab57b5e5ec1398acaebd2..a6a18431866d0ec59f06d66a0b3619e8c9a6c420 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_094.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_094.cpp
@@ -45,7 +45,7 @@ static VOID *pthread_f02(void *argument)
     ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT);
     g_testCount++;
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f01(void *argument)
@@ -75,7 +75,7 @@ static VOID *pthread_f01(void *argument)
     g_testCount++;
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_095.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_095.cpp
index 9a67603b49ba3d7f18d9e5d14bddd532fdf49032..b1bcff37266125853433193fbeddccdda382c688 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_095.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_095.cpp
@@ -50,7 +50,7 @@ static VOID *pthread_f02(void *argument)
 
     g_testCnt1++;
 EXIT:
-    return (void *)9;
+    return reinterpret_cast<void *>(9); // 9: return value for testing
 }
 
 static VOID *pthread_f01(void *argument)
@@ -83,7 +83,7 @@ static VOID *pthread_f01(void *argument)
     g_testCnt1++;
 
 EXIT:
-    return (void *)9;
+    return static_cast<void *>(9); // 9: return value for testing
 }
 
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_107.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_107.cpp
index 9578c6c4c304a9413ffc4d9cd06fcf6b7d8aa22c..0f57cf6aa78b287ab1ea29572422909dcbc4ad47 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_107.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_107.cpp
@@ -32,7 +32,7 @@
 
 static VOID *pthread_f01(void *t)
 {
-    long myId = (long)t;
+    long myId = static_cast<long>(t);
     int rc;
 
     rc = pthread_mutex_lock(&g_pthreadMutexTest1);
@@ -58,7 +58,7 @@ EXIT:
 static VOID *pthread_f02(void *t)
 {
     int i;
-    long myId = (long)t;
+    long myId = static_cast<long>(t);
     int rc;
 
     ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
@@ -74,7 +74,7 @@ static VOID *pthread_f02(void *t)
     ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT);
     g_testCount++;
 
-    rc = pthread_mutex_unlock(&g_pthreadMutexTest1); /* Ϊ�߳���ѯ������������ʱ */
+    rc = pthread_mutex_unlock(&g_pthreadMutexTest1); /* Ϊ�߳���ѯ������������ʱ */
     ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
     LosTaskDelay(2);
 
@@ -87,11 +87,11 @@ static UINT32 Testcase(VOID)
     long t1 = 1, t2 = 2, t3 = 3;
     int rc;
     pthread_t threads[3];
-    pthread_attr_t attr; /* ��ʼ���������������������� */
+    pthread_attr_t attr; /* ��ʼ���������������������� */
 
     g_testCount = 0;
     pthread_mutex_init(&g_pthreadMutexTest1, NULL);
-    pthread_cond_init(&g_pthreadCondTest1, NULL); /* �����߳�ʱ��Ϊ������״̬��������ֲ */
+    pthread_cond_init(&g_pthreadCondTest1, NULL); /* �����߳�ʱ��Ϊ������״̬��������ֲ */
     pthread_attr_init(&attr);
 
     rc = pthread_create(&threads[0], &attr, pthread_f01, (void *)t1);
@@ -101,13 +101,13 @@ static UINT32 Testcase(VOID)
     ICUNIT_ASSERT_EQUAL(rc, 0, rc);
 
 
-    /* �ȴ������߳���� */
+    /* �ȴ������߳���� */
     for (i = 0; i < 2; i++) {
         rc = pthread_join(threads[i], NULL);
         ICUNIT_ASSERT_EQUAL(rc, 0, rc);
     }
 
-    /* ������˳� */
+    /* ������˳� */
     rc = pthread_attr_destroy(&attr);
     ICUNIT_ASSERT_EQUAL(rc, 0, rc);
 
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_138.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_138.cpp
index e3dcf40c351b8fde536736ae49218331c52cff2b..322c6ae416fc00d9ff8ed0653416de0ef1a8e39a 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_138.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_138.cpp
@@ -51,8 +51,9 @@ static UINT32 Testcase(VOID)
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
     /* Make sure the thread was created before we join it. */
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_join(newTh, &valuePtr);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_233.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_233.cpp
index b552fdb1ee9921e2dd88daf9646ef0d2385e185e..09619dfc631cd2579915af3faf3a46a4719345c6 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_233.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_233.cpp
@@ -52,8 +52,9 @@ static VOID *pthread_f01(VOID *tmp)
 
     g_pthreadSem = 1;
 
-    while (1)
+    while (1) {
         sleep(5);
+    }
     return NULL;
 }
 
@@ -69,8 +70,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, pthread_f01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == 0)
+    while (g_pthreadSem == 0) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_238.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_238.cpp
index 1de43f2104c0c8f562720955d808b76449a0070c..d07bb99effbddfa87e36a77178e646c524e8ed65 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_238.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_238.cpp
@@ -44,8 +44,9 @@ static VOID *pthread_f01(VOID *argument)
 
     g_pthreadSem = PTHREAD_INMAIN_TEST;
 
-    while (g_pthreadSem == PTHREAD_INMAIN_TEST)
+    while (g_pthreadSem == PTHREAD_INMAIN_TEST) {
         sleep(1);
+    }
 
     pthread_testcancel();
 
@@ -66,8 +67,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, pthread_f01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_239.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_239.cpp
index db32e99f7cd6be88092d89f5469007d856613555..a40642caf787b75813877f94b6275ec343390788 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_239.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_239.cpp
@@ -41,8 +41,9 @@ static VOID *pthread_f01(VOID *argument)
 
     g_pthreadSem = PTHREAD_INMAIN_TEST;
 
-    while (g_pthreadSem == PTHREAD_INMAIN_TEST)
+    while (g_pthreadSem == PTHREAD_INMAIN_TEST) {
         sleep(1);
+    }
 
     pthread_testcancel();
 
@@ -62,8 +63,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, pthread_f01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_240.cpp b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_240.cpp
index b35e1677d78c708fd9d4255bb30901d99f2f2ae1..77ea3fdcde4f4a9adc90a174dc378a34a0813815 100644
--- a/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_240.cpp
+++ b/testsuites/unittest/libc/posix/pthread/full/It_posix_pthread_240.cpp
@@ -41,8 +41,9 @@ static VOID *pthread_f01(VOID *argument)
 
     g_pthreadSem = PTHREAD_INMAIN_TEST;
 
-    while (g_pthreadSem == PTHREAD_INMAIN_TEST)
+    while (g_pthreadSem == PTHREAD_INMAIN_TEST) {
         sleep(1);
+    }
 
     pthread_testcancel();
 
@@ -63,8 +64,9 @@ static UINT32 Testcase(VOID)
     ret = pthread_create(&newTh, NULL, pthread_f01, NULL);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
 
-    while (g_pthreadSem == PTHREAD_INTHREAD_TEST)
+    while (g_pthreadSem == PTHREAD_INTHREAD_TEST) {
         sleep(1);
+    }
 
     ret = pthread_cancel(newTh);
     ICUNIT_ASSERT_EQUAL(ret, PTHREAD_NO_ERROR, ret);
diff --git a/testsuites/unittest/libc/posix/pthread/posix_pthread_test.cpp b/testsuites/unittest/libc/posix/pthread/posix_pthread_test.cpp
index 5356206840f071196b372a119807b709750b9496..b9bc707b6b19a06af062908a27b62a71e9cde343 100644
--- a/testsuites/unittest/libc/posix/pthread/posix_pthread_test.cpp
+++ b/testsuites/unittest/libc/posix/pthread/posix_pthread_test.cpp
@@ -62,24 +62,24 @@ sem_t g_pthreadSem1;
 sem_t g_pthreadSem2;
 
 __scenario g_scenarii[] = {
-    CASE_POS(0, 0, 0, 0, 0, 0, 0, 0, (char *)"default"),
-    CASE_POS(1, 0, 0, 0, 0, 0, 0, 0, (char *)"detached"),
-    CASE_POS(0, 1, 0, 0, 0, 0, 0, 0, (char *)"Explicit sched"),
-    CASE_UNK(0, 0, 1, 0, 0, 0, 0, 0, (char *)"FIFO Policy"),
-    CASE_UNK(0, 0, 2, 0, 0, 0, 0, 0, (char *)"RR Policy"),
-    CASE_UNK(0, 0, 0, 1, 0, 0, 0, 0, (char *)"Max sched param"),
-    CASE_UNK(0, 0, 0, -1, 0, 0, 0, 0, (char *)"Min sched param"),
-    CASE_POS(0, 0, 0, 0, 1, 0, 0, 0, (char *)"Alternative contension scope"),
-    CASE_POS(0, 0, 0, 0, 0, 1, 0, 0, (char *)"Alternative stack"),
-    CASE_POS(0, 0, 0, 0, 0, 0, 1, 0, (char *)"No guard size"),
-    CASE_UNK(0, 0, 0, 0, 0, 0, 2, 0, (char *)"1p guard size"),
-    CASE_POS(0, 0, 0, 0, 0, 0, 0, 1, (char *)"Min stack size"),
+    CASE_POS(0, 0, 0, 0, 0, 0, 0, 0, const_cast<char *>("default")),
+    CASE_POS(1, 0, 0, 0, 0, 0, 0, 0, const_cast<char *>("detached")),
+    CASE_POS(0, 1, 0, 0, 0, 0, 0, 0, const_cast<char *>("Explicit sched")),
+    CASE_UNK(0, 0, 1, 0, 0, 0, 0, 0, const_cast<char *>("FIFO Policy")),
+    CASE_UNK(0, 0, 2, 0, 0, 0, 0, 0, const_cast<char *>("RR Policy")),
+    CASE_UNK(0, 0, 0, 1, 0, 0, 0, 0, const_cast<char *>("Max sched param")),
+    CASE_UNK(0, 0, 0, -1, 0, 0, 0, 0, const_cast<char >("Min sched param")),
+    CASE_POS(0, 0, 0, 0, 1, 0, 0, 0, const_cast<char *>("Alternative contension scope")),
+    CASE_POS(0, 0, 0, 0, 0, 1, 0, 0, const_cast<char *>("Alternative stack")),
+    CASE_POS(0, 0, 0, 0, 0, 0, 1, 0, const_cast<char *>("No guard size")),
+    CASE_UNK(0, 0, 0, 0, 0, 0, 2, 0, const_cast<char *>("1p guard size")),
+    CASE_POS(0, 0, 0, 0, 0, 0, 0, 1, const_cast<char *>("Min stack size")),
     /* Stack play */
-    CASE_POS(0, 0, 0, 0, 0, 0, 1, 1, (char *)"Min stack size, no guard"),
-    CASE_UNK(0, 0, 0, 0, 0, 0, 2, 1, (char *)"Min stack size, 1p guard"),
-    CASE_POS(1, 0, 0, 0, 0, 1, 0, 0, (char *)"Detached, Alternative stack"),
-    CASE_POS(1, 0, 0, 0, 0, 0, 1, 1, (char *)"Detached, Min stack size, no guard"),
-    CASE_UNK(1, 0, 0, 0, 0, 0, 2, 1, (char *)"Detached, Min stack size, 1p guard"),
+    CASE_POS(0, 0, 0, 0, 0, 0, 1, 1, const_cast<char *>("Min stack size, no guard")),
+    CASE_UNK(0, 0, 0, 0, 0, 0, 2, 1, const_cast<char *>("Min stack size, 1p guard")),
+    CASE_POS(1, 0, 0, 0, 0, 1, 0, 0, const_cast<char *>("Detached, Alternative stack")),
+    CASE_POS(1, 0, 0, 0, 0, 0, 1, 1, const_cast<char *>("Detached, Min stack size, no guard")),
+    CASE_UNK(1, 0, 0, 0, 0, 0, 2, 1, const_cast<char *>("Detached, Min stack size, 1p guard")),
 };
 
 pthread_t g_pthreadTestTh;
diff --git a/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_004.cpp b/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_004.cpp
index b1436e51f21607d63fd156a83a4e599b99a6dea4..24e5b84a7e3acd0953ccc7ea1e9ec9977ab6294c 100644
--- a/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_004.cpp
+++ b/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_004.cpp
@@ -32,7 +32,7 @@
 
 static void *ThreadF01(void *arg)
 {
-    pthread_exit((void *)2);
+    pthread_exit(static_cast<void *>(2)); // 2: return value for testing
     return NULL;
 }
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_005.cpp b/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_005.cpp
index 67729f026578dd567ea41f814f39b1f706ed43e1..9ccb21ec416433d85f3e4fec425f66cc0d556d38 100644
--- a/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_005.cpp
+++ b/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_005.cpp
@@ -38,7 +38,7 @@ static void *ThreadF01(void *arg)
      * function did not succeed. */
     // uart_printf_func("Could not send cancel request correctly\n");
     // ICUNIT_TRACK_EQUAL(1, 0, errno);
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     return NULL;
 }
 static UINT32 Testcase(VOID)
diff --git a/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_006.cpp b/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_006.cpp
index 61342e52b617f3f94193d4e4138aa12fee2a96ee..0389711ccaf3163ca0ff2e652139eb139f4fdb4c 100644
--- a/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_006.cpp
+++ b/testsuites/unittest/libc/posix/pthread/smoke/It_posix_pthread_006.cpp
@@ -37,7 +37,7 @@ static void *ThreadF01(void *arg)
     // while (1)
     sleep(1);
 
-    pthread_exit((void *)0);
+    pthread_exit(nullptr);
     return NULL;
 }
 
diff --git a/testsuites/unittest/libc/sys/smoke/sys_test_008.cpp b/testsuites/unittest/libc/sys/smoke/sys_test_008.cpp
index a3ec1724d9c9ef24b63cbeeddc3760ea88997a2a..a3265976634bc98758c3798fca8d9b7c69a4066a 100644
--- a/testsuites/unittest/libc/sys/smoke/sys_test_008.cpp
+++ b/testsuites/unittest/libc/sys/smoke/sys_test_008.cpp
@@ -39,9 +39,9 @@ static UINT32 TestCase(VOID)
     int cflags;
     regex_t reg;
     char *a = NULL;
-    char *b = (char *)"No error";
-    char *testStr = (char *)"Hello World";
-    char *regStr = (char *)"H.*";
+    char *b = const_cast<char *>("No error");
+    char *testStr = const_cast<char *>("Hello World");
+    char *regStr = const_cast<char *>("H.*");
 
     cflags = REG_EXTENDED | REG_ICASE | REG_NOSUB;
 
diff --git a/testsuites/unittest/libc/sys/smoke/sys_test_009.cpp b/testsuites/unittest/libc/sys/smoke/sys_test_009.cpp
index b19f3f23c4b7797bff1e714c21bbf59f38d4027f..d851f55881cd465f92df36b5999f72d6c55a454f 100644
--- a/testsuites/unittest/libc/sys/smoke/sys_test_009.cpp
+++ b/testsuites/unittest/libc/sys/smoke/sys_test_009.cpp
@@ -33,8 +33,8 @@
 static UINT32 TestCase(VOID)
 {
     char *val = NULL;
-    const char *name = (char *)"ABC";
-    char *env = (char *)"test-test";
+    const char *name = "ABC";
+    char *env = const_cast<char *>("test-test");
     int ret;
 
     val = getenv(name);
diff --git a/testsuites/unittest/libc/sys/smoke/sys_test_010.cpp b/testsuites/unittest/libc/sys/smoke/sys_test_010.cpp
index 60415c50564d727731c0c91d17ca16f366f61a9d..903bb9792360dd3ceb4af6e8bbee1a1798819715 100644
--- a/testsuites/unittest/libc/sys/smoke/sys_test_010.cpp
+++ b/testsuites/unittest/libc/sys/smoke/sys_test_010.cpp
@@ -33,7 +33,7 @@
 static UINT32 TestCase(VOID)
 {
     char *plocale = NULL;
-    char *buffer = (char *)"C";
+    char *buffer = const_cast<char *>("C");
     int ret;
 
     plocale = setlocale(LC_ALL, NULL);
diff --git a/testsuites/unittest/libc/sys/smoke/sys_test_012.cpp b/testsuites/unittest/libc/sys/smoke/sys_test_012.cpp
index 352839a8de7f95f8d7b34cba936b056b18af4351..130013e29469a2c59f906f109c12d97b2c2aa589 100644
--- a/testsuites/unittest/libc/sys/smoke/sys_test_012.cpp
+++ b/testsuites/unittest/libc/sys/smoke/sys_test_012.cpp
@@ -34,8 +34,8 @@ static UINT32 TestCase(VOID)
 {
     char *val = NULL;
     char *val2 = NULL;
-    const char *name = (char *)"ABC";
-    char *env = (char *)"test-test";
+    const char *name = "ABC";
+    char *env = "test-test";
     int ret;
 
     val = getenv(name);
diff --git a/testsuites/unittest/libc/sys/smoke/sys_test_013.cpp b/testsuites/unittest/libc/sys/smoke/sys_test_013.cpp
index 97f9b074ce564d31ebeee7be8887e17a98956182..08c637435b1950930652adda16c0fce636f21a81 100644
--- a/testsuites/unittest/libc/sys/smoke/sys_test_013.cpp
+++ b/testsuites/unittest/libc/sys/smoke/sys_test_013.cpp
@@ -38,7 +38,7 @@ struct q {
 
 static struct q *New(int i)
 {
-    struct q *q = (struct q *)malloc(sizeof *q);
+    struct q *q = static_cast<struct q *>(malloc(sizeof *q));
     if (q != NULL) {
         q->i = i;
     }
diff --git a/testsuites/unittest/libc/sys/smoke/sys_test_016.cpp b/testsuites/unittest/libc/sys/smoke/sys_test_016.cpp
index c53c9ddacc63009d1f81f37c91652183781ecd73..ce5df7780a134721efe8667ce6e1ae366d0d699d 100644
--- a/testsuites/unittest/libc/sys/smoke/sys_test_016.cpp
+++ b/testsuites/unittest/libc/sys/smoke/sys_test_016.cpp
@@ -35,7 +35,7 @@ static UINT32 TestCase(VOID)
     char *ptr = NULL;
     int ret;
 
-    ptr = basename((char *)".");
+    ptr = basename(const_cast<char *>("."));
     ret = strcmp(ptr, ".");
     ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
 
diff --git a/testsuites/unittest/libc/time/clock/full/clock_test_010.cpp b/testsuites/unittest/libc/time/clock/full/clock_test_010.cpp
index 2b14879b3ad203e7e933b63e8a8213e89c7e238d..e57dc25aca7328c6b444bed0cc623bd811e71ee1 100644
--- a/testsuites/unittest/libc/time/clock/full/clock_test_010.cpp
+++ b/testsuites/unittest/libc/time/clock/full/clock_test_010.cpp
@@ -51,8 +51,8 @@ static int SleepTest(int64_t expectTime)
     ret = clock_gettime(clk, &oldtp);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    tp.tv_sec = expectTime / (long)1e9;
-    tp.tv_nsec = expectTime % (long)1e9;
+    tp.tv_sec = expectTime / static_cast<long>(1e9);
+    tp.tv_nsec = expectTime % static_cast<long>(1e9);
     ret = clock_nanosleep(clk, 0, &tp, nullptr);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
@@ -60,7 +60,7 @@ static int SleepTest(int64_t expectTime)
     ret = clock_gettime(clk, &tp);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    escapeTime = (tp.tv_sec - oldtp.tv_sec) * (int64_t)1e9  + (tp.tv_nsec - oldtp.tv_nsec);
+    escapeTime = (tp.tv_sec - oldtp.tv_sec) * static_cast<int64_t>(1e9)  + (tp.tv_nsec - oldtp.tv_nsec);
     LogPrintln("slept time (expected --> actual): %" PRId64 "ns --> %" PRId64 "ns, delta: %" PRId64 "ns\n", expectTime,
         escapeTime, escapeTime - expectTime);
 
diff --git a/testsuites/unittest/libc/time/timer/smoke/timer_test_003.cpp b/testsuites/unittest/libc/time/timer/smoke/timer_test_003.cpp
index f6cfab911f9f250add001cfec11ebd385ff947ff..ae454defb955544388ec2d4feeb90dbe94411a27 100644
--- a/testsuites/unittest/libc/time/timer/smoke/timer_test_003.cpp
+++ b/testsuites/unittest/libc/time/timer/smoke/timer_test_003.cpp
@@ -94,8 +94,9 @@ static int SetTimerTest(void)
         ret = clock_gettime(CLOCKID, &end);
         ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-        expected = its.it_value.tv_sec * (int64_t)1e9 + its.it_value.tv_nsec;
-        escaped = end.tv_sec * (int64_t)1e9 + end.tv_nsec - start.tv_sec * (int64_t)1e9 - start.tv_nsec;
+        expected = its.it_value.tv_sec * static_cast<int64_t>(1e9) + its.it_value.tv_nsec;
+        escaped = end.tv_sec * static_cast<int64_t>(1e9) + end.tv_nsec - start.tv_sec * static_cast<int64_t>(1e9) -
+                  start.tv_nsec;
 
         failed += (escaped < expected || (escaped - expected) >= 20000000); // 20000000, 2 ticks.
     }
diff --git a/testsuites/unittest/libc/time/timer/smoke/timer_test_004.cpp b/testsuites/unittest/libc/time/timer/smoke/timer_test_004.cpp
index e28ec8d45c90ece34d547b50de2584cc5972e18e..059f7b85bd90924e3db3238e561f71393baa781e 100644
--- a/testsuites/unittest/libc/time/timer/smoke/timer_test_004.cpp
+++ b/testsuites/unittest/libc/time/timer/smoke/timer_test_004.cpp
@@ -52,7 +52,7 @@ static void SigHandler(int sig, siginfo_t *si, void *uc)
 #ifdef TEST_ON_LINUX
     timer_t timerid = *(timer_t *)si->si_value.sival_ptr;
 #else // SA_SIGINFO not compatible with POSIX on HMOS
-    timer_t timerid = *(timer_t *)si;
+    timer_t timerid = *reinterpret_cast<timer_t *>(si);
 #endif
 
     g_tmrOverrun += timer_getoverrun(timerid);
diff --git a/testsuites/unittest/libc/time/timer/smoke/timer_test_005.cpp b/testsuites/unittest/libc/time/timer/smoke/timer_test_005.cpp
index 1d3f929915ab69c9b7f6ee27a08e022911247eab..9ef06c128c1a6a4b43d1cd5a55d192582d805e9d 100644
--- a/testsuites/unittest/libc/time/timer/smoke/timer_test_005.cpp
+++ b/testsuites/unittest/libc/time/timer/smoke/timer_test_005.cpp
@@ -69,7 +69,7 @@ static int TimerTest(void)
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     sev.sigev_notify = SIGEV_THREAD;
     sev.sigev_notify_function = TempSigHandler;
-    sev.sigev_value.sival_ptr = (void *)TempSigHandler01;
+    sev.sigev_value.sival_ptr = reinterpret_cast<void *>(TempSigHandler01);
 
     /* Start the timer */
     its.it_value.tv_sec = 3; // 3, timer time 3 seconds.
@@ -89,7 +89,7 @@ static int TimerTest(void)
     its.it_interval.tv_sec = its.it_value.tv_sec;
     its.it_interval.tv_nsec = its.it_value.tv_nsec;
 
-    sev.sigev_value.sival_ptr = (void *)TempSigHandler02;
+    sev.sigev_value.sival_ptr = reinterpret_cast<void *>(TempSigHandler02);
     ret = timer_create(CLOCK_REALTIME, &sev, &timerid02);
     LogPrintln("timer_settime %p: %d", timerid02, ret);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
diff --git a/testsuites/unittest/libc/time/timer/smoke/timer_test_tzset_002.cpp b/testsuites/unittest/libc/time/timer/smoke/timer_test_tzset_002.cpp
index 311def898a974cb76327641d2e6440c2a2281bb6..9834c6b51d3dad9494702147723637d5e8f40b53 100644
--- a/testsuites/unittest/libc/time/timer/smoke/timer_test_tzset_002.cpp
+++ b/testsuites/unittest/libc/time/timer/smoke/timer_test_tzset_002.cpp
@@ -42,7 +42,7 @@ static UINT32 testcase(VOID)
     int ret = 0;
 
     errno = 0;
-    ret = putenv((char *) "TZ=GMT-100");
+    ret = putenv(const_cast<char *>("TZ=GMT-100"));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     tzset();
 
diff --git a/testsuites/unittest/libc/util/smoke/util_test_007.cpp b/testsuites/unittest/libc/util/smoke/util_test_007.cpp
index 80dc8212453916315ebe70d798d7a69b3af324e3..ecc3dd3f911d84d3ba9c0ddc8756aafc59b19868 100644
--- a/testsuites/unittest/libc/util/smoke/util_test_007.cpp
+++ b/testsuites/unittest/libc/util/smoke/util_test_007.cpp
@@ -49,10 +49,10 @@ static void *Xmalloc(unsigned n)
 
 static int Compare(const void *pa, const void *pb)
 {
-    if (*(int *)pa < *(int *)pb) {
+    if (*static_cast<int *>(const_cast<void *>(pa)) < *static_cast<int *>(const_cast<void *>(pb))) {
         return -1;
     }
-    if (*(int *)pa > *(int *)pb) {
+    if (*static_cast<int *>(const_cast<void *>(pa)) > *static_cast<int *>(const_cast<void *>(pb))) {
         return 1;
     }
     return 0;
@@ -66,12 +66,14 @@ static void Action(const void *nodep, VISIT which, int depth)
         case preorder:
             break;
         case postorder:
-            datap = *(int **)nodep;
+            datap = *static_cast<int **>(const_cast<void *>(nodep));
             break;
         case endorder:
             break;
         case leaf:
-            datap = *(int **)nodep;
+            datap = *static_cast<int **>(const_cast<void *>(nodep));
+            break;
+        default:
             break;
     }
 }
@@ -86,7 +88,7 @@ static UINT32 TestCase(VOID)
     for (i = 0; i < 12; i++) {
         ptr = (int *)Xmalloc(sizeof(int));
         *ptr = rand() & 0xff;
-        val = tsearch((void *)ptr, &g_root, Compare);
+        val = tsearch(static_cast<void *>(ptr), &g_root, Compare);
         if (val == NULL) {
             exit(EXIT_FAILURE);
         } else if ((*(int **)val) != ptr) {
diff --git a/testsuites/unittest/net/resolv/smoke/net_resolv_test_001.cpp b/testsuites/unittest/net/resolv/smoke/net_resolv_test_001.cpp
index 3a41448d4e9bb82abd3e0bb38c9309f4c0807ead..bf981653080f25fa57fac62fc30edc86e7eda232 100644
--- a/testsuites/unittest/net/resolv/smoke/net_resolv_test_001.cpp
+++ b/testsuites/unittest/net/resolv/smoke/net_resolv_test_001.cpp
@@ -47,32 +47,32 @@ static int DnCompTest(void)
     unsigned char **lastdnptr = &dnptrs[6];
     int offset, ret;
 
-    offset = strlen((const char *)dnptrs[0])+1;
-    ret = dn_comp("x.y.z.example.com", comp_dn+offset, sizeof(comp_dn)-offset, dnptrs, lastdnptr);
-    dump(comp_dn+offset, ret);
+    offset = strlen(reinterpret_cast<const char *>(dnptrs[0]))+1;
+    ret = dn_comp("x.y.z.example.com", comp_dn + offset, sizeof(comp_dn) - offset, dnptrs, lastdnptr);
+    dump(comp_dn + offset, ret);
     ICUNIT_ASSERT_EQUAL(ret, 19, ret);
-    ICUNIT_ASSERT_EQUAL(dnptrs[1], comp_dn+offset, dnptrs[1]);
+    ICUNIT_ASSERT_EQUAL(dnptrs[1], comp_dn + offset, dnptrs[1]);
 
     offset += ret+1;
-    ret = dn_comp("zz.example.com", comp_dn+offset, sizeof(comp_dn)-offset, dnptrs, lastdnptr);
+    ret = dn_comp("zz.example.com", comp_dn + offset, sizeof(comp_dn) - offset, dnptrs, lastdnptr);
     dump(comp_dn+offset, ret);
     ICUNIT_ASSERT_EQUAL(ret, 5, ret);
-    ICUNIT_ASSERT_EQUAL(dnptrs[2], comp_dn+offset, dnptrs[2]);
+    ICUNIT_ASSERT_EQUAL(dnptrs[2], comp_dn + offset, dnptrs[2]);
 
     offset += ret+1;
-    ret = dn_comp("a.example.com", comp_dn+offset, sizeof(comp_dn)-offset, dnptrs, lastdnptr);
+    ret = dn_comp("a.example.com", comp_dn + offset, sizeof(comp_dn) - offset, dnptrs, lastdnptr);
     dump(comp_dn+offset, ret);
     ICUNIT_ASSERT_EQUAL(ret, 4, ret);
-    ICUNIT_ASSERT_EQUAL(dnptrs[3], comp_dn+offset, dnptrs[3]);
+    ICUNIT_ASSERT_EQUAL(dnptrs[3], comp_dn + offset, dnptrs[3]);
 
     offset += ret+1;
-    ret = dn_comp("example.com.cn", comp_dn+offset, sizeof(comp_dn)-offset, dnptrs, lastdnptr);
+    ret = dn_comp("example.com.cn", comp_dn + offset, sizeof(comp_dn) - offset, dnptrs, lastdnptr);
     dump(comp_dn+offset, ret);
     ICUNIT_ASSERT_EQUAL(ret, 16, ret);
-    ICUNIT_ASSERT_EQUAL(dnptrs[4], comp_dn+offset, dnptrs[4]);
+    ICUNIT_ASSERT_EQUAL(dnptrs[4], comp_dn + offset, dnptrs[4]);
 
     offset += ret+1;
-    ret = dn_comp("2example.com", comp_dn+offset, sizeof(comp_dn)-offset, dnptrs, lastdnptr);
+    ret = dn_comp("2example.com", comp_dn + offset, sizeof(comp_dn) - offset, dnptrs, lastdnptr);
     dump(comp_dn+offset, ret);
     ICUNIT_ASSERT_EQUAL(ret, 11, ret);
     ICUNIT_ASSERT_EQUAL(dnptrs[5], /*comp_dn+offset*/ NULL, dnptrs[5]); //last one is always NULL
@@ -80,7 +80,7 @@ static int DnCompTest(void)
     for (int i = 0; i < 6; ++i) {
         printf("%p: %s\n", dnptrs[i], dnptrs[i]);
     }
-    ICUNIT_ASSERT_EQUAL(offset+ret<100, 1, ret);
+    ICUNIT_ASSERT_EQUAL(offset + ret < 100, 1, ret);
     return ICUNIT_SUCCESS;
 }
 
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_002.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_002.cpp
index 20d2193c8a15896f9f375916e4a49644e1706b6e..d0a4ce685da8bb51f938acb60968785a884b68d1 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_002.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_002.cpp
@@ -64,7 +64,7 @@ static int UdpTest(void)
     srvAddr.sin_family = AF_INET;
     srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
     srvAddr.sin_port = htons(STACK_PORT);
-    ret = bind(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    ret = bind(sfd, reinterpret_cast<struct sockaddr *>(&srvAddr), sizeof(srvAddr));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
     /* send */
@@ -75,14 +75,14 @@ static int UdpTest(void)
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ret = strcpy_s(g_buf, BUF_SIZE, MSG);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = sendto(sfd, g_buf, strlen(MSG), 0, (struct sockaddr*)&clnAddr,
-        (socklen_t)sizeof(clnAddr));
+    ret = sendto(sfd, g_buf, strlen(MSG), 0, reinterpret_cast<struct sockaddr *>(&clnAddr),
+        static_cast<socklen_t>(sizeof(clnAddr)));
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
 
     /* recv */
     ret = memset_s(g_buf, BUF_SIZE, 0, BUF_SIZE);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = recvfrom(sfd, g_buf, sizeof(g_buf), 0, (struct sockaddr*)&clnAddr,
+    ret = recvfrom(sfd, g_buf, sizeof(g_buf), 0, reinterpret_cast<struct sockaddr *>(&clnAddr),
         &clnAddrLen);
     ICUNIT_ASSERT_EQUAL(ret, strlen(MSG), ret);
 
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_003.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_003.cpp
index 925002140819471b28721677d8d594d9276fcb0c..d180968f3ad7de4df6e5dd86485af8d5dbf2f8c5 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_003.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_003.cpp
@@ -68,7 +68,7 @@ static int SampleTcpServer()
     srvAddr.sin_family = AF_INET;
     srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
     srvAddr.sin_port = htons(STACK_PORT);
-    ret = bind(lsfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    ret = bind(lsfd, reinterpret_cast<struct sockaddr *>(&srvAddr), sizeof(srvAddr));
     LogPrintln("bind socket %d to %s:%d: %d", lsfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
     ICUNIT_ASSERT_EQUAL(ret, 0, Wait() + ret);
 
@@ -78,7 +78,7 @@ static int SampleTcpServer()
 
     Wait();
 
-    sfd = accept(lsfd, (struct sockaddr*)&clnAddr, &clnAddrLen);
+    sfd = accept(lsfd, reinterpret_cast<struct sockaddr *>(&clnAddr), &clnAddrLen);
     LogPrintln("accept socket %d: %d <%s:%d>", lsfd, sfd, inet_ntoa(clnAddr.sin_addr), ntohs(clnAddr.sin_port));
     ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, sfd);
 
@@ -175,25 +175,27 @@ static int SampleTcpClient()
     srvAddr.sin_family = AF_INET;
     srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
     srvAddr.sin_port = htons(PEER_PORT);
-    ret = connect(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    ret = connect(sfd, reinterpret_cast<struct sockaddr *>(&srvAddr), sizeof(srvAddr));
     LogPrintln("connect socket %d to %s:%d: %d", sfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
     /* test getpeername */
     ret = getpeername(sfd, &addr, &addrLen);
-    LogPrintln("getpeername %d %s:%d: %d", sfd, inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr), ntohs(((struct sockaddr_in*)&addr)->sin_port), ret);
+    LogPrintln("getpeername %d %s:%d: %d", sfd, inet_ntoa((reinterpret_cast<struct sockaddr_in *>(&addr))->sin_addr),
+        ntohs((reinterpret_cast<struct sockaddr_in *>(&addr))->sin_port), ret);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ICUNIT_ASSERT_EQUAL(addrLen, sizeof(struct sockaddr_in), addrLen);
-    ICUNIT_ASSERT_EQUAL(((struct sockaddr_in*)&addr)->sin_addr.s_addr,
-        inet_addr(PEER_IP), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
+    ICUNIT_ASSERT_EQUAL((reinterpret_cast<struct sockaddr_in *>(&addr))->sin_addr.s_addr,
+        inet_addr(PEER_IP), (static_cast<struct sockaddr_in *>(&addr))->sin_addr.s_addr);
 
     /* test getsockname */
     ret = getsockname(sfd, &addr, &addrLen);
-    LogPrintln("getsockname %d %s:%d: %d", sfd, inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr), ntohs(((struct sockaddr_in*)&addr)->sin_port), ret);
+    LogPrintln("getsockname %d %s:%d: %d", sfd, inet_ntoa((reinterpret_cast<struct sockaddr_in *>(&addr))->sin_addr),
+        ntohs((reinterpret_cast<struct sockaddr_in *>(&addr))->sin_port), ret);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ICUNIT_ASSERT_EQUAL(addrLen, sizeof(struct sockaddr_in), addrLen);
-    ICUNIT_ASSERT_EQUAL(((struct sockaddr_in*)&addr)->sin_addr.s_addr,
-        inet_addr(STACK_IP), ((struct sockaddr_in*)&addr)->sin_addr.s_addr);
+    ICUNIT_ASSERT_EQUAL((reinterpret_cast<struct sockaddr_in *>(&addr))->sin_addr.s_addr,
+        inet_addr(STACK_IP), (static_cast<struct sockaddr_in *>(&addr))->sin_addr.s_addr);
 
     /* send */
     ret = memset_s(gBuf, BUF_SIZE + 1, 0, BUF_SIZE + 1);
@@ -267,13 +269,13 @@ static int SampleTcpClient()
 static void* TcpServerRoutine(void *p)
 {
     int ret = SampleTcpServer();
-    return (void*)(intptr_t)ret;
+    return reinterpret_cast<void *>(ret);
 }
 
 static void* TcpClientRoutine(void *p)
 {
     int ret = SampleTcpClient();
-    return (void*)(intptr_t)ret;
+    return reinterpret_cast<void *>(ret);
 }
 
 static int TcpTest()
@@ -312,7 +314,7 @@ static int TcpTest()
     ret = pthread_barrier_destroy(&gBarrier);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    return (int)(intptr_t)(sret) + (int)(intptr_t)(cret);
+    return static_cast<int>(reinterpret_cast<intptr_t>(sret)) + static_cast<int>(reinterpret_cast<intptr_t>(cret));
 }
 
 void NetSocketTest003(void)
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_007.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_007.cpp
index 94bc166b46286b0bd2a846a7996f26edf20259dd..1ceece685c9be62adc93a762549ea1ffa6c97497 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_007.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_007.cpp
@@ -45,90 +45,100 @@ static int TcpTest()
     lsfd = socket(AF_INET, SOCK_STREAM, 0);
     ICUNIT_ASSERT_NOT_EQUAL(lsfd, -1, lsfd);
 
-    ret = bind(lsfd, (const struct sockaddr *)INVALID_USER_ADDR, sizeof(struct sockaddr_in));
+    ret = bind(lsfd, reinterpret_cast<const struct sockaddr *>(INVALID_USER_ADDR), sizeof(struct sockaddr_in));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = bind(lsfd, (const struct sockaddr *)INVALID_KERNEL_ADDR, sizeof(struct sockaddr_in));
+    ret = bind(lsfd, reinterpret_cast<const struct sockaddr *>(INVALID_KERNEL_ADDR), sizeof(struct sockaddr_in));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = connect(lsfd, (struct sockaddr*)INVALID_USER_ADDR, sizeof(struct sockaddr_in));
+    ret = connect(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_USER_ADDR), sizeof(struct sockaddr_in));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = connect(lsfd, (struct sockaddr*)INVALID_KERNEL_ADDR, sizeof(struct sockaddr_in));
+    ret = connect(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_KERNEL_ADDR), sizeof(struct sockaddr_in));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = accept(lsfd, (struct sockaddr*)INVALID_USER_ADDR, (socklen_t *)INVALID_USER_ADDR);
+    ret = accept(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_USER_ADDR),
+                 reinterpret_cast<socklen_t *>(INVALID_USER_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = accept(lsfd, (struct sockaddr*)INVALID_KERNEL_ADDR, (socklen_t *)INVALID_KERNEL_ADDR);
+    ret = accept(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_KERNEL_ADDR),
+                 reinterpret_cast<socklen_t *>(INVALID_KERNEL_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = getsockname(lsfd, (struct sockaddr*)INVALID_USER_ADDR, (socklen_t *)INVALID_USER_ADDR);
+    ret = getsockname(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_USER_ADDR),
+                      reinterpret_cast<socklen_t *>(INVALID_USER_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = getsockname(lsfd, (struct sockaddr*)INVALID_KERNEL_ADDR, (socklen_t *)INVALID_KERNEL_ADDR);
+    ret = getsockname(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_KERNEL_ADDR),
+                      reinterpret_cast<socklen_t *>(INVALID_KERNEL_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = getpeername(lsfd, (struct sockaddr*)INVALID_USER_ADDR, (socklen_t *)INVALID_USER_ADDR);
+    ret = getpeername(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_USER_ADDR),
+                      reinterpret_cast<socklen_t *>(INVALID_USER_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = getpeername(lsfd, (struct sockaddr*)INVALID_KERNEL_ADDR, (socklen_t *)INVALID_KERNEL_ADDR);
+    ret = getpeername(lsfd, reinterpret_cast<struct sockaddr *>(INVALID_KERNEL_ADDR),
+                      reinterpret_cast<socklen_t *>(INVALID_KERNEL_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = send(lsfd, (char *)INVALID_USER_ADDR, strlen(SRV_MSG), 0);
+    ret = send(lsfd, reinterpret_cast<char *>(INVALID_USER_ADDR), strlen(SRV_MSG), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = send(lsfd, (char *)INVALID_KERNEL_ADDR, strlen(SRV_MSG), 0);
+    ret = send(lsfd, reinterpret_cast<char *>(INVALID_KERNEL_ADDR), strlen(SRV_MSG), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = sendto(lsfd, (char *)INVALID_USER_ADDR, strlen(SRV_MSG), 0, (struct sockaddr*)INVALID_USER_ADDR,
-        (socklen_t)sizeof(struct sockaddr_in));
+    ret = sendto(lsfd, reinterpret_cast<char *>(INVALID_USER_ADDR), strlen(SRV_MSG), 0,
+        reinterpret_cast<struct sockaddr *>(INVALID_USER_ADDR), static_cast<socklen_t>(sizeof(struct sockaddr_in)));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = sendto(lsfd, (char *)INVALID_KERNEL_ADDR, strlen(SRV_MSG), 0, (struct sockaddr*)INVALID_KERNEL_ADDR,
-        (socklen_t)sizeof(struct sockaddr_in));
+    ret = sendto(lsfd, reinterpret_cast<char *>(INVALID_KERNEL_ADDR), strlen(SRV_MSG), 0,
+        reinterpret_cast<struct sockaddr *>(INVALID_KERNEL_ADDR), static_cast<socklen_t>(sizeof(struct sockaddr_in)));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = recv(lsfd, (char *)INVALID_USER_ADDR, sizeof(SRV_MSG), 0);
+    ret = recv(lsfd, reinterpret_cast<char *>(INVALID_USER_ADDR), sizeof(SRV_MSG), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = recv(lsfd, (char *)INVALID_KERNEL_ADDR, sizeof(SRV_MSG), 0);
+    ret = recv(lsfd, reinterpret_cast<char *>(INVALID_KERNEL_ADDR), sizeof(SRV_MSG), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = recvfrom(lsfd, (char *)INVALID_USER_ADDR, sizeof(SRV_MSG), 0, (struct sockaddr*)INVALID_USER_ADDR,
-        (socklen_t *)INVALID_USER_ADDR);
+    ret = recvfrom(lsfd, reinterpret_cast<char *>(INVALID_USER_ADDR), sizeof(SRV_MSG), 0,
+        reinterpret_cast<struct sockaddr *>(INVALID_USER_ADDR), reinterpret_cast<socklen_t *>(INVALID_USER_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = recvfrom(lsfd, (char *)INVALID_KERNEL_ADDR, sizeof(SRV_MSG), 0, (struct sockaddr*)INVALID_KERNEL_ADDR,
-        (socklen_t *)INVALID_KERNEL_ADDR);
+    ret = recvfrom(lsfd, reinterpret_cast<char *>(INVALID_KERNEL_ADDR), sizeof(SRV_MSG), 0,
+        reinterpret_cast<struct sockaddr *>(INVALID_KERNEL_ADDR), reinterpret_cast<socklen_t *>(INVALID_KERNEL_ADDR));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = setsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, (struct timeval *)INVALID_USER_ADDR, (socklen_t)sizeof(struct timeval));
+    ret = setsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<struct timeval *>(INVALID_USER_ADDR),
+                     static_cast<socklen_t>(sizeof(struct timeval)));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = setsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, (struct timeval *)INVALID_KERNEL_ADDR, (socklen_t)sizeof(struct timeval));
+    ret = setsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<struct timeval *>(INVALID_KERNEL_ADDR),
+                     static_cast<socklen_t>(sizeof(struct timeval)));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = getsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, (struct timeval *)INVALID_USER_ADDR, (socklen_t*)sizeof(struct timeval));
+    ret = getsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<struct timeval *>(INVALID_USER_ADDR),
+                     reinterpret_cast<socklen_t *>(sizeof(struct timeval)));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = getsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, (struct timeval *)INVALID_KERNEL_ADDR, (socklen_t*)sizeof(struct timeval));
+    ret = getsockopt(lsfd, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<struct timeval *>(INVALID_KERNEL_ADDR),
+                     reinterpret_cast<socklen_t *>(sizeof(struct timeval)));
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = sendmsg(lsfd, (struct msghdr *)INVALID_USER_ADDR, 0);
+    ret = sendmsg(lsfd, reinterpret_cast<struct msghdr *>(INVALID_USER_ADDR), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = sendmsg(lsfd, (struct msghdr *)INVALID_KERNEL_ADDR, 0);
+    ret = sendmsg(lsfd, reinterpret_cast<struct msghdr *>(INVALID_KERNEL_ADDR), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    msg.msg_name = (char *)INVALID_USER_ADDR;
+    msg.msg_name = reinterpret_cast<char *>(INVALID_USER_ADDR);
     msg.msg_namelen = sizeof(struct sockaddr_in);
-    msg.msg_iov = (struct iovec *)INVALID_KERNEL_ADDR;
+    msg.msg_iov = reinterpret_cast<struct iovec *>(INVALID_KERNEL_ADDR);
     msg.msg_iovlen = 2;
-    ret = recvmsg(lsfd, (struct msghdr *)&msg, 0);
+    ret = recvmsg(lsfd, static_cast<struct msghdr *>(&msg), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
-    ret = recvmsg(lsfd, (struct msghdr *)&msg, 0);
+    ret = recvmsg(lsfd, static_cast<struct msghdr *>(&msg), 0);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
 
 #ifdef TEST_BIG_MEM
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_008.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_008.cpp
index dd76e80bd55a4590b73996a96d79f4e1302f2e83..49e642b5d2effcf1f22de846f980bbb347f4ac59 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_008.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_008.cpp
@@ -121,7 +121,7 @@ static int HandleAccept(int lsfd)
 {
     struct sockaddr_in sa;
     int saLen = sizeof(sa);
-    int fd = accept(lsfd, (struct sockaddr *)&sa, (socklen_t *)&saLen);
+    int fd = accept(lsfd, reinterpret_cast<struct sockaddr *>(&sa), reinterpret_cast<socklen_t *>(&saLen));
     if (fd == INVALID_SOCKET) {
         perror("accept");
         return -1;
@@ -168,7 +168,7 @@ static void *ClientsThread(void *param)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
     sa.sin_port = htons(SERVER_PORT);
-    if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
+    if (connect(fd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa)) == -1) {
         perror("connect");
         return NULL;
     }
@@ -224,7 +224,7 @@ static int SelectTest(void)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = htonl(INADDR_ANY);
     sa.sin_port = htons(SERVER_PORT);
-    ret = bind(lsfd, (struct sockaddr *)&sa, sizeof(sa));
+    ret = bind(lsfd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa));
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, errno + CloseAllFd());
 
     ret = listen(lsfd, BACKLOG);
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_009.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_009.cpp
index f864727ef56e293f33fcc48f3fbbeefe892981d3..9d76513cbac81ea644890e8e2100ba65047bb5cd 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_009.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_009.cpp
@@ -120,7 +120,7 @@ static int HandleAccept(int lsfd)
 {
     struct sockaddr_in sa;
     int saLen = sizeof(sa);
-    int fd = accept(lsfd, (struct sockaddr *)&sa, (socklen_t *)&saLen);
+    int fd = accept(lsfd, reinterpret_cast<struct sockaddr *>(&sa), reinterpret_cast<socklen_t *>(&saLen));
     if (fd == INVALID_SOCKET) {
         perror("accept");
         return -1;
@@ -168,7 +168,7 @@ static void *ClientsThread(void *param)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
     sa.sin_port = htons(SERVER_PORT);
-    if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
+    if (connect(fd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa)) == -1) {
         perror("connect");
         return NULL;
     }
@@ -224,7 +224,7 @@ static int PollTest(void)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = htonl(INADDR_ANY);
     sa.sin_port = htons(SERVER_PORT);
-    ret = bind(lsfd, (struct sockaddr *)&sa, sizeof(sa));
+    ret = bind(lsfd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa));
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, errno + CloseAllFd());
 
     ret = listen(lsfd, BACKLOG);
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_010.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_010.cpp
index 0021c20ce0057ff8b5718bb672b23bd3b026c3d1..f4478be159861f7be844d611f095f31579dcd75e 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_010.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_010.cpp
@@ -117,11 +117,11 @@ static int IoctlTestInternal(int sfd)
     LogPrintln("ifindex %u: %s", lanIndex, p);
     ICUNIT_ASSERT_NOT_EQUAL(p, NULL, errno);
 
-    ret = strncpy_s(gDefaultNetif, sizeof(gDefaultNetif) -1, p, sizeof(gDefaultNetif) - 1);
+    ret = strncpy_s(gDefaultNetif, sizeof(gDefaultNetif) - 1, p, sizeof(gDefaultNetif) - 1);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     gDefaultNetif[sizeof(gDefaultNetif) - 1] = '\0';
 
-    ret = (int)IfName2Index(sfd, p);
+    ret = static_cast<int>(IfName2Index(sfd, p));
     LogPrintln("index of %s: %d", p, ret);
     ICUNIT_ASSERT_NOT_EQUAL(ret, 0, errno);
 
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_011.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_011.cpp
index e71a30c7928ea974ba8020de577bb8e1ecdf13de..a6e428756b06d5eee4732920723ea3bfc890b1e7 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_011.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_011.cpp
@@ -143,7 +143,7 @@ static void *ClientsThread(void *param)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
     sa.sin_port = htons(SERVER_PORT);
-    if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
+    if (connect(fd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa)) == -1) {
         perror("connect");
         return NULL;
     }
@@ -204,7 +204,7 @@ static int UdpSelectTest(void)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = htonl(INADDR_ANY);
     sa.sin_port = htons(SERVER_PORT);
-    ret = bind(lsfd, (struct sockaddr *)&sa, sizeof(sa));
+    ret = bind(lsfd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa));
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, errno + CloseAllFd());
 
     InitFds();
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_012.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_012.cpp
index f7d684c297b7efdfa32f50eec21415347c59bf35..f2f0a034112a37d609585434add30228dffe2d0b 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_012.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_012.cpp
@@ -43,11 +43,11 @@ static int SocketNullTestInternal(int sfd)
 {
     int ret;
     struct sockaddr addr = {0};
-    struct sockaddr *bad = (struct sockaddr *)0xbad;
+    struct sockaddr *bad = reinterpret_cast<struct sockaddr *>(0xbad);
     socklen_t addrlen = sizeof(addr);
     socklen_t zero = 0;
     struct msghdr message = {0};
-    void *badUserAddr = (void*)0x3effffff;
+    void *badUserAddr = reinterpret_cast<void *>(0x3effffff);
 
     /**
      * accept
@@ -216,13 +216,13 @@ static int SocketNullTestInternal(int sfd)
     LogPrintln("recvmsg: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL(ret, -1, errno);
 
-    message.msg_iov = (struct iovec *)((void *)0xbad);
+    message.msg_iov = reinterpret_cast<struct iovec *>(0xbad);
     message.msg_iovlen = 1;
     ret = recvmsg(sfd, &message, MSG_DONTWAIT);
     LogPrintln("recvmsg: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL(ret, -1, errno);
 
-    message.msg_iov = (struct iovec *)((void *)0xbad);
+    message.msg_iov = reinterpret_cast<struct iovec *>(0xbad);
     message.msg_iovlen = 0;
     ret = recvmsg(sfd, &message, MSG_DONTWAIT);
     LogPrintln("recvmsg: %d, errno=%d", ret, errno);
@@ -264,13 +264,13 @@ static int SocketNullTestInternal(int sfd)
     LogPrintln("sendmsg: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL(ret, -1, errno);
 
-    message.msg_iov = (struct iovec *)0xbad;
+    message.msg_iov = reinterpret_cast<struct iovec *>(0xbad);
     message.msg_iovlen = 1;
     ret = sendmsg(sfd, &message, MSG_NOSIGNAL);
     LogPrintln("sendmsg: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL(ret, -1, errno);
 
-    message.msg_iov = (struct iovec *)0xbad;
+    message.msg_iov = reinterpret_cast<struct iovec *>(0xbad);
     message.msg_iovlen = 0;
     ret = sendmsg(sfd, &message, MSG_NOSIGNAL);
     LogPrintln("sendmsg: %d, errno=%d", ret, errno);
@@ -326,11 +326,11 @@ static int SocketNullTestInternal(int sfd)
     LogPrintln("read: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL((ret == 0 || ret == -1), 1, errno);
 
-    ret = readv(sfd, (struct iovec *)bad, 0);
+    ret = readv(sfd, reinterpret_cast<struct iovec *>(bad), 0);
     LogPrintln("readv: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL((ret == 0 || ret == -1), 1, errno);
 
-    ret = readv(sfd, (struct iovec *)bad, 1);
+    ret = readv(sfd, reinterpret_cast<struct iovec *>(bad), 1);
     LogPrintln("readv: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL(ret, -1, errno);
 
@@ -377,11 +377,11 @@ static int SocketNullTestInternal(int sfd)
     LogPrintln("write: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL((ret == 0 || ret == -1), 1, errno);
 
-    ret = writev(sfd, (struct iovec *)bad, 0);
+    ret = writev(sfd, reinterpret_cast<struct iovec *>(bad), 0);
     LogPrintln("writev: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL((ret == 0 || ret == -1), 1, errno);
 
-    ret = writev(sfd, (struct iovec *)bad, 1);
+    ret = writev(sfd, reinterpret_cast<struct iovec *>(bad), 1);
     LogPrintln("writev: %d, errno=%d", ret, errno);
     ICUNIT_ASSERT_EQUAL(ret, -1, errno);
 
diff --git a/testsuites/unittest/net/socket/smoke/net_socket_test_013.cpp b/testsuites/unittest/net/socket/smoke/net_socket_test_013.cpp
index 1f4356861b79e9ea131cc68d54cd1d9fa4bca843..6c129f181615fdaf372f92ef5ada7b5d863d6a80 100644
--- a/testsuites/unittest/net/socket/smoke/net_socket_test_013.cpp
+++ b/testsuites/unittest/net/socket/smoke/net_socket_test_013.cpp
@@ -140,7 +140,7 @@ static unsigned int GetIp(int sfd, const char *ifname)
     ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
     ret = ioctl(sfd, SIOCGIFADDR, &ifr);
     if (ret == 0) {
-        ip = ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr.s_addr;
+        ip = (reinterpret_cast<struct sockaddr_in *>(&(ifr.ifr_addr)))->sin_addr.s_addr;
     }
     return ip;
 }
@@ -156,7 +156,7 @@ static unsigned int GetNetmask(int sfd, const char *ifname)
     ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
     ret = ioctl(sfd, SIOCGIFNETMASK, &ifr);
     if (ret == 0) {
-        msk = ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr.s_addr;
+        msk = (reinterpret_cast<struct sockaddr_in *>(&(ifr.ifr_addr)))->sin_addr.s_addr;
     }
     return msk;
 }
@@ -207,7 +207,7 @@ static void *ClientsThread(void *param)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = brdcast;
     sa.sin_port = htons(SERVER_PORT);
-    if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
+    if (connect(fd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa)) == -1) {
         perror("connect");
         return NULL;
     }
@@ -263,7 +263,7 @@ static int UdpBrdcastSelectTest(void)
     sa.sin_family = AF_INET;
     sa.sin_addr.s_addr = htonl(INADDR_ANY);
     sa.sin_port = htons(SERVER_PORT);
-    ret = bind(lsfd, (struct sockaddr *)&sa, sizeof(sa));
+    ret = bind(lsfd, reinterpret_cast<struct sockaddr *>(&sa), sizeof(sa));
     ICUNIT_ASSERT_NOT_EQUAL(ret, -1, errno + CloseAllFd());
 
     int broadcast = 1;
diff --git a/testsuites/unittest/process/basic/process/full/process_test_042.cpp b/testsuites/unittest/process/basic/process/full/process_test_042.cpp
index 188cdf79d920be42ff56a4fb0959052de3fd2678..bade0abedddcf0656c2e4b5be37a7b260aa5e6ee 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_042.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_042.cpp
@@ -38,7 +38,7 @@ static void Child2(int shmid)
 {
     int count = 2; // 2, Set the calculation number to determine the cycle status.
     int *shared = (int *)shmat(shmid, nullptr, 0);
-    ICUNIT_ASSERT_NOT_EQUAL_VOID(shared, (void *)-1, shared);
+    ICUNIT_ASSERT_NOT_EQUAL_VOID(shared, reinterpret_cast<void *>(-1), shared);
 
     while ((*shared) < (TEST_LOOP + 2)) { // 2, Set the cycle number.
         ICUNIT_ASSERT_EQUAL_VOID(*shared, count, *shared);
@@ -55,7 +55,7 @@ static void Child1(int shmid)
 {
     int count = 1;
     int *shared = (int *)shmat(shmid, nullptr, 0);
-    ICUNIT_ASSERT_NOT_EQUAL_VOID(shared, (void *)-1, shared);
+    ICUNIT_ASSERT_NOT_EQUAL_VOID(shared, reinterpret_cast<void *>(-1), shared);
 
     while ((*shared) < (TEST_LOOP + 1)) {
         ICUNIT_ASSERT_EQUAL_VOID(*shared, count, *shared);
@@ -92,7 +92,8 @@ static int GroupProcess(void)
     ret = pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    shmid = shmget((key_t)1234, memSize, 0666 | IPC_CREAT); // 1234, Sets the shmget key; 0666 config of shmget
+    /* 1234, Sets the shmget key; 0666 config of shmget */
+    shmid = shmget(static_cast<key_t>(1234), memSize, 0666 | IPC_CREAT);
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     pid = fork();
@@ -112,7 +113,7 @@ static int GroupProcess(void)
     }
 
     shared = (int *)shmat(shmid, nullptr, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(shared, (void *)-1, shared);
+    ICUNIT_ASSERT_NOT_EQUAL(shared, reinterpret_cast<void *>(-1), shared);
 
     (*shared) = 0;
 
diff --git a/testsuites/unittest/process/basic/process/full/process_test_049.cpp b/testsuites/unittest/process/basic/process/full/process_test_049.cpp
index ff3f58322229aae2c256db5e18638ca82db52e11..740352ee7ea6fc3ed5f87c6a90ef0ba2ba86e239 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_049.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_049.cpp
@@ -88,14 +88,14 @@ static int Testcase(void)
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     g_shmptr = (int *)shmat(shmid, nullptr, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, (int *)-1, g_shmptr);
+    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, reinterpret_cast<int *>(-1), g_shmptr);
 
     *g_shmptr = 0;
 
-    stack = (char *)malloc(arg);
+    stack = static_cast<char *>(malloc(arg));
     ICUNIT_GOTO_NOT_EQUAL(stack, NULL, stack, EXIT1);
 
-    stackTop = (char *)((unsigned long)stack + arg);
+    stackTop = reinterpret_cast<char *>(reinterpret_cast<unsigned long>(stack) + arg);
     pid = clone(TestThread, (void *)stackTop, CLONE_VFORK, &arg);
 
     ICUNIT_GOTO_EQUAL(*g_shmptr, arg, *g_shmptr, EXIT2);
diff --git a/testsuites/unittest/process/basic/process/full/process_test_050.cpp b/testsuites/unittest/process/basic/process/full/process_test_050.cpp
index 839cb15164843a1b0980a78c8f619e668e455bf6..720cde9c0f4f1965f45b0a08bb2d9444dd6e41ed 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_050.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_050.cpp
@@ -60,7 +60,7 @@ static int Testcase(void)
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     g_shmptr = (int *)shmat(shmid, nullptr, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, (int *)-1, g_shmptr);
+    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, reinterpret_cast<int *>(-1), g_shmptr);
 
     *g_shmptr = 0;
 
@@ -70,7 +70,7 @@ static int Testcase(void)
     stack = malloc(arg);
     ICUNIT_GOTO_NOT_EQUAL(stack, NULL, stack, EXIT1);
 
-    stackTop = (char *)((unsigned long)stack + arg);
+    stackTop = reinterpret_cast<char *>(reinterpret_cast<unsigned long>(stack) + arg);
     pid = clone(TestThread, (void *)stackTop, CLONE_PARENT, &arg);
 
     ret = waitpid(pid, &status, NULL);
diff --git a/testsuites/unittest/process/basic/process/full/process_test_051.cpp b/testsuites/unittest/process/basic/process/full/process_test_051.cpp
index 4eed43672aa5af672012e4c44d7c0b1512a2a3a5..2e29096adec7ab868ac034fdee9bd30a0cc2bd4e 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_051.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_051.cpp
@@ -75,7 +75,7 @@ static int Testcase(void)
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     g_shmptr = (int *)shmat(shmid, nullptr, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, (int *)-1, g_shmptr);
+    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, reinterpret_cast<int *>(-1), g_shmptr);
 
     *g_shmptr = 0;
 
@@ -85,7 +85,7 @@ static int Testcase(void)
     stack = malloc(arg);
     ICUNIT_GOTO_NOT_EQUAL(stack, NULL, stack, EXIT1);
 
-    stackTop = (char *)((unsigned long)stack + arg);
+    stackTop = reinterpret_cast<char *>(reinterpret_cast<unsigned long>(stack) + arg);
     pid = clone(TestThread, (void *)stackTop, CLONE_PARENT | CLONE_VFORK, &arg);
 
     ICUNIT_GOTO_EQUAL(*g_shmptr, 100, *g_shmptr, EXIT2); // 100, assert g_shmptr equal to this.
diff --git a/testsuites/unittest/process/basic/process/full/process_test_052.cpp b/testsuites/unittest/process/basic/process/full/process_test_052.cpp
index 9b88ddb61318ac35cd1728e151eb765c3ef652e9..f4f13a43d0acb13fd9f5499d5d16c060a28aa510 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_052.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_052.cpp
@@ -58,17 +58,17 @@ static int Testcase(void)
     ICUNIT_ASSERT_NOT_EQUAL(shmid, -1, shmid);
 
     g_shmptr = (int *)shmat(shmid, nullptr, 0);
-    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, (int *)-1, g_shmptr);
+    ICUNIT_ASSERT_NOT_EQUAL(g_shmptr, static_cast<int *>(-1), g_shmptr);
 
     *g_shmptr = 0;
 
     g_ppid = getppid();
     printf("testcase ppid : %d\n", g_ppid);
 
-    void *stack = (void *)malloc(arg);
+    void *stack = malloc(arg);
     ICUNIT_GOTO_NOT_EQUAL(stack, NULL, stack, EXIT1);
 
-    char *stackTop = (char *)((unsigned long)stack + arg);
+    char *stackTop = static_cast<char *>(static_cast<unsigned long>(stack) + arg);
     pid_t pid = clone(TestThread, (char *)stackTop, CLONE_PARENT | CLONE_VFORK | CLONE_FILES, &arg);
 
     ICUNIT_GOTO_EQUAL(*g_shmptr, 100, *g_shmptr, EXIT2); // 100, assert g_shmptr equal to this.
diff --git a/testsuites/unittest/process/basic/process/full/process_test_062.cpp b/testsuites/unittest/process/basic/process/full/process_test_062.cpp
index 3f2398a538ae4b76d61a8f68a46111e2984eaa42..ad4128b1818bb92d9da9ecea8a711344e5add701 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_062.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_062.cpp
@@ -95,12 +95,12 @@ static int TestCase(void)
     status = WEXITSTATUS(status);
     ICUNIT_GOTO_EQUAL(status, 10, status, EXIT); // 10, assert that function Result is equal to this.
 
-    shmdt((void *)g_shmptr);
+    shmdt(static_cast<void *>(const_cast<int *>(g_shmptr)));
     shmctl(shmid, IPC_RMID, NULL);
 
     return 0;
 EXIT:
-    shmdt((void *)g_shmptr);
+    shmdt(static_cast<void *>(const_cast<int *>(g_shmptr)));
     shmctl(shmid, IPC_RMID, NULL);
     return 1;
 }
diff --git a/testsuites/unittest/process/basic/process/full/process_test_063.cpp b/testsuites/unittest/process/basic/process/full/process_test_063.cpp
index d68956531f7a127385d4753391fd91c03df9e6ac..86353e0aabb463e240bffe147b83f777718bd78f 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_063.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_063.cpp
@@ -52,12 +52,12 @@ static void GetRandomData(char **buf, int bufSize)
     char *p = *buf;
     int i;
 
-    srand((unsigned)time(0));
+    srand(static_cast<unsigned>(time(0)));
     for (i = 0; i < bufSize - 1; ++i) {
         int r = GetRandomNumber(RANDOM_MAX);
-        *(p + i) = (char)r;
+        *(p + i) = static_cast<char>(r);
     }
-    *(p + i) = (char)0;
+    *(p + i) = static_cast<char>(0);
 }
 
 static int TestCase(VOID)
@@ -73,36 +73,36 @@ static int TestCase(VOID)
     ret = posix_spawn(&pid, NULL, NULL, NULL, NULL, NULL);
     ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
 
-    childFileName = (char *)1;
+    childFileName = reinterpret_cast<char *>(1);
     ret = posix_spawn(&pid, childFileName, NULL, NULL, NULL, NULL);
     ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
 
-    childArgv = (char **)1;
+    childArgv = reinterpret_cast<char **>(1);
     ret = posix_spawn(&pid, "/usr/bin/testsuits_app", NULL, NULL, childArgv, NULL);
     ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
 
-    childEnvp = (char **)1;
+    childEnvp = reinterpret_cast<char **>(1);
     ret = posix_spawn(&pid, "/usr/bin/testsuits_app", NULL, NULL, NULL, childEnvp);
     ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
 
     ret = posix_spawn(&pid, "/bin", NULL, NULL, NULL, NULL);
     ICUNIT_ASSERT_EQUAL(ret, ENOENT, ret);
 
-    fileName = (char *)malloc(FILE_NAME_BYTES);
+    fileName = static_cast<char *>(malloc(FILE_NAME_BYTES));
     ICUNIT_ASSERT_NOT_EQUAL(fileName, NULL, fileName);
     GetRandomData(&fileName, FILE_NAME_BYTES);
     ret = posix_spawn(&pid, fileName, NULL, NULL, NULL, NULL);
     free(fileName);
     ICUNIT_ASSERT_EQUAL(ret, ENOENT, ret);
 
-    fileName = (char *)malloc(LONG_FILE_NAME_BYTES);
+    fileName = static_cast<char *>(malloc(LONG_FILE_NAME_BYTES));
     ICUNIT_ASSERT_NOT_EQUAL(fileName, NULL, fileName);
     GetRandomData(&fileName, LONG_FILE_NAME_BYTES);
     ret = posix_spawn(&pid, fileName, NULL, NULL, NULL, NULL);
     free(fileName);
     ICUNIT_ASSERT_EQUAL(ret, ENAMETOOLONG, ret);
 
-    ret = posix_spawn(&pid, (char *)INVALID_USER_VADDR, NULL, NULL, NULL, NULL);
+    ret = posix_spawn(&pid, reinterpret_cast<char *>(INVALID_USER_VADDR), nullptr, nullptr, nullptr, nullptr);
     ICUNIT_ASSERT_EQUAL(ret, EFAULT, ret);
 
     return 0;
diff --git a/testsuites/unittest/process/basic/process/full/process_test_064.cpp b/testsuites/unittest/process/basic/process/full/process_test_064.cpp
index 3b84cbbb1828e20f0974ed6a24cee8a4ab57829a..ace3138476a128833ade137439c0751a63c19dff 100644
--- a/testsuites/unittest/process/basic/process/full/process_test_064.cpp
+++ b/testsuites/unittest/process/basic/process/full/process_test_064.cpp
@@ -52,12 +52,12 @@ static void GetRandomData(char **buf, int bufSize)
     char *p = *buf;
     int i;
 
-    srand((unsigned)time(0));
+    srand(static_cast<unsigned>(time(0)));
     for (i = 0; i < bufSize - 1; ++i) {
         int r = GetRandomNumber(RANDOM_MAX);
-        *(p + i) = (char)r;
+        *(p + i) = static_cast<char>(r);
     }
-    *(p + i) = (char)0;
+    *(p + i) = static_cast<char>(0);
 }
 
 static int TestCase(VOID)
@@ -70,25 +70,25 @@ static int TestCase(VOID)
     char **childArgv = NULL;
     char **childEnvp = NULL;
 
-    childArgv = (char **)1;
+    childArgv = reinterpret_cast<char **>(1);
     ret = posix_spawnp(&pid, "/usr/bin/testsuits_app", NULL, NULL, childArgv, NULL);
     ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
 
-    childEnvp = (char **)1;
+    childEnvp = reinterpret_cast<char **>(1);
     ret = posix_spawnp(&pid, "/usr/bin/testsuits_app", NULL, NULL, NULL, childEnvp);
     ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
 
     ret = posix_spawnp(&pid, "/bin", NULL, NULL, NULL, NULL);
     ICUNIT_ASSERT_EQUAL(ret, ENOENT, ret);
 
-    fileName = (char *)malloc(FILE_NAME_BYTES);
+    fileName = static_cast<char *>(malloc(FILE_NAME_BYTES));
     ICUNIT_ASSERT_NOT_EQUAL(fileName, NULL, fileName);
     GetRandomData(&fileName, FILE_NAME_BYTES);
     ret = posix_spawnp(&pid, fileName, NULL, NULL, NULL, NULL);
     free(fileName);
     ICUNIT_ASSERT_EQUAL(ret, ENOENT, ret);
 
-    fileName = (char *)malloc(LONG_FILE_NAME_BYTES);
+    fileName = static_cast<char *>(malloc(LONG_FILE_NAME_BYTES));
     ICUNIT_ASSERT_NOT_EQUAL(fileName, NULL, fileName);
     GetRandomData(&fileName, LONG_FILE_NAME_BYTES);
     ret = posix_spawnp(&pid, fileName, NULL, NULL, NULL, NULL);
diff --git a/testsuites/unittest/process/basic/process/it_test_process.h b/testsuites/unittest/process/basic/process/it_test_process.h
index 19803d4a9fb298ed243171d173d31def0335a81c..ac4879581b033ad9679e2806bfb8b193203efd63 100644
--- a/testsuites/unittest/process/basic/process/it_test_process.h
+++ b/testsuites/unittest/process/basic/process/it_test_process.h
@@ -40,11 +40,11 @@
 
 static inline int Syscall(int nbr, int parm1, int parm2, int parm3, int parm4)
 {
-    register int reg7 __asm__("r7") = (int)(nbr);
-    register int reg3 __asm__("r3") = (int)(parm4);
-    register int reg2 __asm__("r2") = (int)(parm3);
-    register int reg1 __asm__("r1") = (int)(parm2);
-    register int reg0 __asm__("r0") = (int)(parm1);
+    register int reg7 __asm__("r7") = nbr;
+    register int reg3 __asm__("r3") = parm4;
+    register int reg2 __asm__("r2") = parm3;
+    register int reg1 __asm__("r1") = parm2;
+    register int reg0 __asm__("r0") = parm1;
 
     __asm__ __volatile__("svc 0" : "=r"(reg0) : "r"(reg7), "r"(reg0), "r"(reg1), "r"(reg2), "r"(reg3) : "memory");
 
diff --git a/testsuites/unittest/process/basic/process/smoke/process_test_023.cpp b/testsuites/unittest/process/basic/process/smoke/process_test_023.cpp
index 578b9f183d0ede1fe1a1e65c9f29a8a77e52454e..7e05574a984474c9927a7ff89b4d9668a1a57951 100644
--- a/testsuites/unittest/process/basic/process/smoke/process_test_023.cpp
+++ b/testsuites/unittest/process/basic/process/smoke/process_test_023.cpp
@@ -46,7 +46,7 @@ static void *ThreadFunc(void *arg)
     ICUNIT_ASSERT_NOT_EQUAL_NULL(g_thread002, 0, g_thread002);
     g_thread001++;
 
-    return (void *)9; // 9, set thread return value.
+    return reinterpret_cast<void *>(9); // 9, set thread return value.
 EXIT:
     return NULL;
 }
@@ -61,7 +61,7 @@ static void *ThreadFunc2(void *arg)
     ICUNIT_ASSERT_NOT_EQUAL_NULL(ret, -1, ret);
     ICUNIT_ASSERT_NOT_EQUAL_NULL(g_thread001, 0, g_thread001);
 
-    return (void *)9; // 9, set thread return value.
+    return reinterpret_cast<void *>(9); // 9, set thread return value.
 EXIT:
     return NULL;
 }
diff --git a/testsuites/unittest/process/basic/pthread/full/pthread_test_001.cpp b/testsuites/unittest/process/basic/pthread/full/pthread_test_001.cpp
index 8c95f11f13684558a81edfeaaf15254665b6631e..b43e9ab35882af31f1e9389372f48cca4acf1871 100644
--- a/testsuites/unittest/process/basic/pthread/full/pthread_test_001.cpp
+++ b/testsuites/unittest/process/basic/pthread/full/pthread_test_001.cpp
@@ -71,7 +71,7 @@ static void *ThreadFunc4(void *arg)
             ret = pthread_cancel(pthread);
         }
     }
-    return (void *)i;
+    return reinterpret_cast<void *>(i);
 
 EXIT:
     return NULL;
@@ -100,7 +100,7 @@ static void *ThreadFunc3(void *arg)
     }
 
     ICUNIT_GOTO_EQUAL(i, 10, i, EXIT); // 10, here assert the result.
-    return (void *)i;
+    return reinterpret_cast<void *>(i);
 EXIT:
     return NULL;
 }
@@ -132,7 +132,7 @@ static void *ThreadFunc6(void *arg)
     ICUNIT_GOTO_EQUAL(g_pthreadTestCount, 12, g_pthreadTestCount, EXIT); // 12, here assert the result.
     g_pthreadTestCount++;                                                // 13
 
-    return (void *)pthread_self();
+    return reinterpret_cast<void *>(pthread_self());
 
 EXIT:
     return NULL;
diff --git a/testsuites/unittest/process/basic/pthread/full/pthread_test_004.cpp b/testsuites/unittest/process/basic/pthread/full/pthread_test_004.cpp
index 18bc242e473bb478c9831ee3d41ef92ac0cafa7f..21613f9b6ea9f031fceb4001614970e079d10e1c 100644
--- a/testsuites/unittest/process/basic/pthread/full/pthread_test_004.cpp
+++ b/testsuites/unittest/process/basic/pthread/full/pthread_test_004.cpp
@@ -163,7 +163,7 @@ static void *ThreadFunc4(void *arg)
             ret = pthread_cancel(pthread);
         }
     }
-    return (void *)i;
+    return reinterpret_cast<void *>(i);
 
 EXIT:
     return NULL;
@@ -196,7 +196,7 @@ static void *ThreadFunc3(void *arg)
     }
 
     ICUNIT_GOTO_EQUAL(i, 10, i, EXIT); // 10, here assert the result.
-    return (void *)i;
+    return reinterpret_cast<void *>(i);
 
 EXIT:
     return NULL;
diff --git a/testsuites/unittest/process/basic/pthread/it_pthread_test.h b/testsuites/unittest/process/basic/pthread/it_pthread_test.h
index 5b148e0192f5f3988e167f847fd31131529275d1..4b4391664baf65240090de9ab99d5cf5a263e95b 100644
--- a/testsuites/unittest/process/basic/pthread/it_pthread_test.h
+++ b/testsuites/unittest/process/basic/pthread/it_pthread_test.h
@@ -42,11 +42,11 @@
 
 static inline int Syscall(int nbr, int parm1, int parm2, int parm3, int parm4)
 {
-    register int reg7 __asm__("r7") = (int)(nbr);
-    register int reg3 __asm__("r3") = (int)(parm4);
-    register int reg2 __asm__("r2") = (int)(parm3);
-    register int reg1 __asm__("r1") = (int)(parm2);
-    register int reg0 __asm__("r0") = (int)(parm1);
+    register int reg7 __asm__("r7") = nbr;
+    register int reg3 __asm__("r3") = parm4;
+    register int reg2 __asm__("r2") = parm3;
+    register int reg1 __asm__("r1") = parm2;
+    register int reg0 __asm__("r0") = parm1;
 
     __asm__ __volatile__("svc 0" : "=r"(reg0) : "r"(reg7), "r"(reg0), "r"(reg1), "r"(reg2), "r"(reg3) : "memory");
 
diff --git a/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp b/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp
index a39d99cd42f4ecbc321801e8124eb2ddbfd71c19..a779ba33910fdb4c91d1757115f3c539fd23a419 100644
--- a/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp
+++ b/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp
@@ -44,7 +44,7 @@ static void *Threadfunc(void *parm)
     int err;
     err = pthread_once(&g_onceCtrl, InitRoutine);
     ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
-    return (void *)g_okStatus;
+    return reinterpret_cast<void *>(g_okStatus);
 EXIT:
     return NULL;
 }
diff --git a/testsuites/unittest/process/basic/pthread/smoke/pthread_test_019.cpp b/testsuites/unittest/process/basic/pthread/smoke/pthread_test_019.cpp
index e219eed46bbbfa764dd744d86d3a16e256a8ac6b..8746c78e3376577d0a981f074b49bd1a41e051c4 100644
--- a/testsuites/unittest/process/basic/pthread/smoke/pthread_test_019.cpp
+++ b/testsuites/unittest/process/basic/pthread/smoke/pthread_test_019.cpp
@@ -77,7 +77,7 @@ static int GroupProcess(void)
     stackSize = 3000; // 3000, change stackSize, test again.
 
     pthread_attr_init(&attr);
-    stack = (void *)0x1000;
+    stack = reinterpret_cast<void *>(0x1000);
 
     ret = pthread_attr_setstack(&attr, stack, stackSize);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
diff --git a/testsuites/unittest/process/lock/rwlock/full/pthread_rwlock_test_002.cpp b/testsuites/unittest/process/lock/rwlock/full/pthread_rwlock_test_002.cpp
index babc6f96499d87aead15901d5b563cf9f20b4fe3..efff5610ed0b9c9775ee06162c082874843eb50b 100644
--- a/testsuites/unittest/process/lock/rwlock/full/pthread_rwlock_test_002.cpp
+++ b/testsuites/unittest/process/lock/rwlock/full/pthread_rwlock_test_002.cpp
@@ -227,7 +227,7 @@ static int PthreadRwlockTest(void)
     int index = 0;
     int curThreadPri, curThreadPolicy;
 
-    ret = memset_s((void *)g_rwlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ret = memset_s(static_cast<void *>(g_rwlockData), sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     g_rwlockMask = 0;
 
diff --git a/testsuites/unittest/process/lock/rwlock/smoke/pthread_rwlock_test_001.cpp b/testsuites/unittest/process/lock/rwlock/smoke/pthread_rwlock_test_001.cpp
index ddeb572f36015f2c597bdbd415b3fd24774c4d4c..a4a19d750ca000a639f9482959779419edcd3763 100644
--- a/testsuites/unittest/process/lock/rwlock/smoke/pthread_rwlock_test_001.cpp
+++ b/testsuites/unittest/process/lock/rwlock/smoke/pthread_rwlock_test_001.cpp
@@ -227,7 +227,7 @@ static int Testcase(void)
     int index = 0;
     int curThreadPri, curThreadPolicy;
 
-    ret = memset_s((void *)g_rwlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ret = memset_s(static_cast<void *>(g_rwlockData), sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     g_rwlockMask = 0;
 
diff --git a/testsuites/unittest/process/lock/spinlock/smoke/pthread_spinlock_test_001.cpp b/testsuites/unittest/process/lock/spinlock/smoke/pthread_spinlock_test_001.cpp
index d03967b1005b819c1cbaa382fd3d9a16c3f41d36..8e73e83da0fd993c0d22030c02cda58dd2d74458 100644
--- a/testsuites/unittest/process/lock/spinlock/smoke/pthread_spinlock_test_001.cpp
+++ b/testsuites/unittest/process/lock/spinlock/smoke/pthread_spinlock_test_001.cpp
@@ -134,7 +134,7 @@ static int Testcase(void)
     int index = 0;
     int curThreadPri, curThreadPolicy;
 
-    ret = memset_s((void *)g_spinlockData, sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
+    ret = memset_s(static_cast<void *>(g_spinlockData), sizeof(int) * TEST_DATA_SIZE, 0, sizeof(int) * TEST_DATA_SIZE);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     g_spinlockMask = 0;
 
diff --git a/testsuites/unittest/security/reugid/smoke/reugid_test_001.cpp b/testsuites/unittest/security/reugid/smoke/reugid_test_001.cpp
index 4dfa614135ebc18cda046b03a98fd71125e9773e..bc558a956e1b52c8daeb718d78465fde46f03c71 100644
--- a/testsuites/unittest/security/reugid/smoke/reugid_test_001.cpp
+++ b/testsuites/unittest/security/reugid/smoke/reugid_test_001.cpp
@@ -51,10 +51,11 @@ static int Child1(int *list, int listSize)
     egid = getegid();
     ICUNIT_ASSERT_EQUAL(egid, 300, egid);
 
-    ret = getresgid((gid_t *)&ruid, (gid_t *)&euid, (gid_t *)&suid);
+    ret = getresgid(reinterpret_cast<gid_t *>(&ruid), reinterpret_cast<gid_t *>(&euid),
+                    reinterpret_cast<gid_t *>(&suid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ICUNIT_ASSERT_EQUAL(ruid, 300, ruid);
-    ICUNIT_ASSERT_EQUAL(euid, 300, euid);
+    ICUNIT_ASSERT_EQUAL(ruid, 300, ruid); // 300: expected ruid
+    ICUNIT_ASSERT_EQUAL(euid, 300, euid); // 300: expected euid
     ICUNIT_ASSERT_EQUAL(suid, 300, suid);
 
     ruid = getuid();
@@ -62,29 +63,30 @@ static int Child1(int *list, int listSize)
     euid = geteuid();
     ICUNIT_ASSERT_EQUAL(euid, 300, euid);
 
-    ret = getresuid((gid_t *)&ruid, (gid_t *)&euid, (gid_t *)&suid);
+    ret = getresuid(reinterpret_cast<gid_t *>(&ruid), reinterpret_cast<gid_t *>(&euid),
+                    reinterpret_cast<gid_t *>(&suid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ICUNIT_ASSERT_EQUAL(ruid, 300, ruid);
+    ICUNIT_ASSERT_EQUAL(ruid, 300, ruid); // 300: expected ruid
     ICUNIT_ASSERT_EQUAL(euid, 300, euid);
     ICUNIT_ASSERT_EQUAL(suid, 300, suid);
 
-    int size = getgroups(0, (gid_t *)getList);
+    int size = getgroups(0, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(size, listSize, size);
 
-    size = getgroups(size, (gid_t *)getList);
+    size = getgroups(size, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(size, listSize, size);
     for (int i = 0; i < size - 1; i++) {
         ICUNIT_ASSERT_EQUAL(getList[i], list[i], getList[i]);
     }
 
     getList[size - 1] = 500;
-    ret = setgroups(0, (gid_t *)getList);
+    ret = setgroups(0, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
     ret = getgroups(0, NULL);
     ICUNIT_ASSERT_EQUAL(ret, 1, ret);
 
-    ret = getgroups(ret, (gid_t *)getList);
+    ret = getgroups(ret, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(ret, 1, ret);
     ICUNIT_ASSERT_EQUAL(getList[0], getgid(), getList[0]);
 
@@ -109,7 +111,7 @@ static int Child(void)
     ret = getgid();
     ICUNIT_ASSERT_EQUAL(ret, 3000, ret);
     ret = getegid();
-    ICUNIT_ASSERT_EQUAL(ret, 3000, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 3000, ret); // 3000: expected egid
 
     ret = setegid(3000);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
@@ -125,50 +127,50 @@ static int Child(void)
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EINVAL, errno, errno);
 
-    list[0] = 1000;
-    list[1] = 2000;
-    list[2] = 3000;
-    list[3] = 4000;
-    list[4] = 5000;
-    ret = setgroups(5, (gid_t *)list);
+    list[0] = 1000; // 1000: preset value of list[0]
+    list[1] = 2000; // 2000: preset value of list[1]
+    list[2] = 3000; // 3000: preset value of list[2]
+    list[3] = 4000; // 4000: preset value of list[3]
+    list[4] = 5000; // 5000: preset value of list[4]
+    ret = setgroups(5, reinterpret_cast<gid_t *>(list)); // 5: set groupid for testing
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    size = getgroups(0, (gid_t *)getList);
+    size = getgroups(0, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(size, 5, size);
 
-    size = getgroups(size, (gid_t *)getList);
+    size = getgroups(size, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(size, 5, size);
 
     for (int i = 0; i < size; i++) {
         ICUNIT_ASSERT_EQUAL(getList[i], list[i], getList[i]);
     }
 
-    list[0] = 1000;
-    list[1] = 2000;
-    list[2] = 6000;
-    list[3] = 4000;
-    list[4] = 5000;
+    list[0] = 1000; // 1000: preset value of list[0]
+    list[1] = 2000; // 2000: preset value of list[1]
+    list[2] = 6000; // 6000: preset value of list[2]
+    list[3] = 4000; // 4000: preset value of list[3]
+    list[4] = 5000; // 5000: preset value of list[4]
     list[5] = -1;
-    ret = setgroups(6, (gid_t *)list);
+    ret = setgroups(6, reinterpret_cast<gid_t *>(list)); // 6: set groupid for testing
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EINVAL, errno, errno);
 
-    list[0] = 1000;
-    list[1] = 2000;
-    list[2] = 6000;
-    list[3] = 4000;
-    list[4] = 5000;
+    list[0] = 1000; // 1000: preset value of list[0]
+    list[1] = 2000; // 2000: preset value of list[1]
+    list[2] = 6000; // 6000: preset value of list[2]
+    list[3] = 4000; // 4000: preset value of list[3]
+    list[4] = 5000; // 5000: preset value of list[4]
     list[5] = 7000;
-    ret = setgroups(6, (gid_t *)list);
+    ret = setgroups(6, reinterpret_cast<gid_t *>(list)); // 6: set groupid for testing
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    size = getgroups(0, (gid_t *)getList);
+    size = getgroups(0, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(size, 7, size);
 
     size = getgroups(0, NULL);
     ICUNIT_ASSERT_EQUAL(size, 7, size);
 
-    size = getgroups(size, (gid_t *)getList);
+    size = getgroups(size, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(size, 7, size);
     for (int i = 0; i < size - 1; i++) {
         ICUNIT_ASSERT_EQUAL(getList[i], list[i], getList[i]);
@@ -180,7 +182,7 @@ static int Child(void)
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
     ret = geteuid();
-    ICUNIT_ASSERT_EQUAL(ret, 8000, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 8000, ret); // 8000: expected value of euid
 
     ret = setuid(2000);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
@@ -203,16 +205,16 @@ static int Child(void)
     ret = setregid(5000, 5000);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ret = getgid();
-    ICUNIT_ASSERT_EQUAL(ret, 5000, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 5000, ret); // 5000: expected value of gid
     egid = getegid();
-    ICUNIT_ASSERT_EQUAL(egid, 5000, egid);
+    ICUNIT_ASSERT_EQUAL(egid, 5000, egid); // 5000: expected value of egid
 
     ret = setregid(5000, -1);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ret = getgid();
-    ICUNIT_ASSERT_EQUAL(ret, 5000, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 5000, ret); // 5000: expected value of gid
     egid = getegid();
-    ICUNIT_ASSERT_EQUAL(egid, 5000, egid);
+    ICUNIT_ASSERT_EQUAL(egid, 5000, egid); // 5000: expected value of egid
 
     ret = setregid(3000, -2);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
@@ -225,9 +227,9 @@ static int Child(void)
     ret = setregid(3000, -1);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ret = getgid();
-    ICUNIT_ASSERT_EQUAL(ret, 3000, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 3000, ret); // 3000: expected value of gid
     egid = getegid();
-    ICUNIT_ASSERT_EQUAL(egid, 3000, egid);
+    ICUNIT_ASSERT_EQUAL(egid, 3000, egid); // 3000: expected value of egid
 
     ret = setreuid(1000, 3000);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
@@ -244,23 +246,24 @@ static int Child(void)
     ret = setreuid(-1, 3000);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ruid = getuid();
-    ICUNIT_ASSERT_EQUAL(ruid, 3000, ruid);
+    ICUNIT_ASSERT_EQUAL(ruid, 3000, ruid); // 3000: expected value of ruid
     euid = geteuid();
-    ICUNIT_ASSERT_EQUAL(euid, 3000, euid);
+    ICUNIT_ASSERT_EQUAL(euid, 3000, euid); // 3000: expected value of euid
 
     ret = setreuid(1000, -1);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ruid = getuid();
-    ICUNIT_ASSERT_EQUAL(ruid, 1000, ruid);
+    ICUNIT_ASSERT_EQUAL(ruid, 1000, ruid); // 1000: expected value of ruid
     euid = geteuid();
-    ICUNIT_ASSERT_EQUAL(euid, 1000, euid);
+    ICUNIT_ASSERT_EQUAL(euid, 1000, euid); // 1000: expected value of euid
 
     ret = setresuid(100, 100, 100);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = getresuid((uid_t *)&ruid, (uid_t *)&euid, (uid_t *)&suid);
+    ret = getresuid(reinterpret_cast<uid_t *>(&ruid), reinterpret_cast<uid_t *>(&euid),
+                    reinterpret_cast<uid_t *>(&suid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ICUNIT_ASSERT_EQUAL(ruid, 100, ruid);
-    ICUNIT_ASSERT_EQUAL(euid, 100, euid);
+    ICUNIT_ASSERT_EQUAL(euid, 100, euid); // 100: expected value of euid
     ICUNIT_ASSERT_EQUAL(suid, 100, suid);
 
     ret = setresuid(200, 100, 100);
@@ -277,18 +280,20 @@ static int Child(void)
 
     ret = setresuid(-1, 200, 200);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = getresuid((uid_t *)&ruid, (uid_t *)&euid, (uid_t *)&suid);
+    ret = getresuid(reinterpret_cast<uid_t *>(&ruid), reinterpret_cast<uid_t *>(&euid),
+                    reinterpret_cast<uid_t *>(&suid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ICUNIT_ASSERT_EQUAL(ruid, 200, ruid);
+    ICUNIT_ASSERT_EQUAL(ruid, 200, ruid); // 200: expected value of ruid
     ICUNIT_ASSERT_EQUAL(euid, 200, euid);
     ICUNIT_ASSERT_EQUAL(suid, 200, suid);
 
-    ret = setresuid(-1, -1, 300);
+    ret = setresuid(-1, -1, 300); // set saved-set user id to 300
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = getresuid((uid_t *)&ruid, (uid_t *)&euid, (uid_t *)&suid);
+    ret = getresuid(reinterpret_cast<uid_t *>(&ruid), reinterpret_cast<uid_t *>(&euid),
+                    reinterpret_cast<uid_t *>(&suid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ICUNIT_ASSERT_EQUAL(ruid, 300, ruid);
-    ICUNIT_ASSERT_EQUAL(euid, 300, euid);
+    ICUNIT_ASSERT_EQUAL(euid, 300, euid); // 300: expected value of euid
     ICUNIT_ASSERT_EQUAL(suid, 300, suid);
 
     ret = setresuid(-1, 200, 300);
@@ -309,13 +314,14 @@ static int Child(void)
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EINVAL, errno, errno);
 
-    ret = setresgid(100, 100, 100);
+    ret = setresgid(100, 100, 100); // 100: value of rgid, egid and sgid
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = getresgid((gid_t *)&rgid, (gid_t *)&egid, (gid_t *)&sgid);
+    ret = getresgid(reinterpret_cast<gid_t *>(&rgid), reinterpret_cast<gid_t *>(&egid),
+                    reinterpret_cast<gid_t *>(&sgid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ICUNIT_ASSERT_EQUAL(rgid, 100, rgid);
     ICUNIT_ASSERT_EQUAL(egid, 100, egid);
-    ICUNIT_ASSERT_EQUAL(sgid, 100, sgid);
+    ICUNIT_ASSERT_EQUAL(sgid, 100, sgid); // 100: expected value of sgid
 
     ret = setresgid(200, 100, 100);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
@@ -329,29 +335,31 @@ static int Child(void)
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EPERM, errno, errno);
 
-    ret = setresgid(-2, 100, 200);
+    ret = setresgid(-2, 100, 200); // set rgid to -2, egid to 100, sgid to 200
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EINVAL, errno, errno);
-    ret = setresgid(100, -2, 200);
+    ret = setresgid(100, -2, 200); // set rgid to 100, egid to -2, sgid to 200
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EINVAL, errno, errno);
-    ret = setresgid(100, 100, -2);
+    ret = setresgid(100, 100, -2); // set rgid and egid to 100, rgid to -2
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EINVAL, errno, errno);
     ret = setresgid(100, -1, -2);
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EINVAL, errno, errno);
-    ret = setresgid(-1, 200, 200);
+    ret = setresgid(-1, 200, 200); // 200: value of egid and sgid
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = getresgid((gid_t *)&rgid, (gid_t *)&egid, (gid_t *)&sgid);
+    ret = getresgid(reinterpret_cast<gid_t *>(&rgid), reinterpret_cast<gid_t *>(&egid),
+                    reinterpret_cast<gid_t *>(&sgid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ICUNIT_ASSERT_EQUAL(rgid, 200, rgid);
-    ICUNIT_ASSERT_EQUAL(egid, 200, egid);
-    ICUNIT_ASSERT_EQUAL(sgid, 200, sgid);
+    ICUNIT_ASSERT_EQUAL(rgid, 200, rgid); // 200: expected value of rgid
+    ICUNIT_ASSERT_EQUAL(egid, 200, egid); // 200: expected value of egid
+    ICUNIT_ASSERT_EQUAL(sgid, 200, sgid); // 200: expected value of sgid
 
-    ret = setresgid(-1, -1, 300);
+    ret = setresgid(-1, -1, 300); // set sgid to 300
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    ret = getresgid((gid_t *)&rgid, (gid_t *)&egid, (gid_t *)&sgid);
+    ret = getresgid(reinterpret_cast<gid_t *>(&rgid), reinterpret_cast<gid_t *>(&egid),
+                    reinterpret_cast<gid_t *>(&sgid));
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
     ICUNIT_ASSERT_EQUAL(rgid, 300, rgid);
     ICUNIT_ASSERT_EQUAL(egid, 300, egid);
@@ -361,8 +369,8 @@ static int Child(void)
     ICUNIT_ASSERT_EQUAL(ret, -1, ret);
     ICUNIT_ASSERT_EQUAL(EPERM, errno, errno);
 
-    size = getgroups(0, (gid_t *)getList);
-    size = getgroups(size, (gid_t *)getList);
+    size = getgroups(0, reinterpret_cast<gid_t *>(getList));
+    size = getgroups(size, reinterpret_cast<gid_t *>(getList));
     pid_t pid = fork();
     if (pid == 0) {
         Child1(getList, size);
@@ -378,10 +386,10 @@ static int Child(void)
     ret = setgroups(0, NULL);
     ICUNIT_ASSERT_EQUAL(ret, 0, ret);
 
-    ret = getgroups(0, (gid_t *)getList);
+    ret = getgroups(0, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(ret, 1, ret);
 
-    ret = getgroups(1, (gid_t *)getList);
+    ret = getgroups(1, reinterpret_cast<gid_t *>(getList));
     ICUNIT_ASSERT_EQUAL(ret, 1, ret);
     ICUNIT_ASSERT_EQUAL(getList[0], getgid(), getList[0]);
 
@@ -411,7 +419,7 @@ static int TestCase(VOID)
     int ret;
     int status = 0;
     pid_t pid = fork();
-    ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT);
+    ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT); // assume pid is between 0 and 100000
     if (pid == 0) {
         ret = Child();
         exit(__LINE__);
diff --git a/testsuites/unittest/security/vid/smoke/vid_test_001.cpp b/testsuites/unittest/security/vid/smoke/vid_test_001.cpp
index 631dcf283277e97021f4eb5cdf80ef6cb8629fa2..8c0994143400072eac8b54477de8b05f472a3fee 100644
--- a/testsuites/unittest/security/vid/smoke/vid_test_001.cpp
+++ b/testsuites/unittest/security/vid/smoke/vid_test_001.cpp
@@ -122,7 +122,7 @@ static void ChildFunc()
     ret1 = (INT32 *)timer_delete(tid);
     ICUNIT_ASSERT_EQUAL_VOID(ret1, 0, ret1);
 
-    exit((int)(intptr_t)tid);
+    exit(static_cast<int>(reinterpret_cast<intptr_t>(tid)));
 }
 
 static UINT32 TestCase(VOID)
diff --git a/tools/scripts/parse_exc/parse_excinfo.py b/tools/scripts/parse_exc/parse_excinfo.py
index feafa01c00d1755d9fe8c03354fd42d0929d5ba0..7f580d8a52c93d83a6825d59df3db2e55663e356 100644
--- a/tools/scripts/parse_exc/parse_excinfo.py
+++ b/tools/scripts/parse_exc/parse_excinfo.py
@@ -33,8 +33,8 @@
 import sys
 import os
 import argparse
-import commands
 import io
+import commands
 
 def find_string(excinfo_file, string):
     res = ''