diff --git a/test/common/dl_operation/dl_operation_test.cpp b/test/common/dl_operation/dl_operation_test.cpp
index dd514d752121dfb76807bd0f68185e9659ef8359..f99c7015dc3967b32088737ca611229fab5ae1f3 100644
--- a/test/common/dl_operation/dl_operation_test.cpp
+++ b/test/common/dl_operation/dl_operation_test.cpp
@@ -59,6 +59,6 @@ HWTEST_F(DlOperationTest, TestDlOption001, TestSize.Level1)
     FUNC_ADD addFunc = (FUNC_ADD)AieDlsym(handle, "AddFunc");
     ASSERT_NE(addFunc, nullptr);
     int result = addFunc(AIE_NUM1, AIE_NUM2);
-    EXPECT_EQ(result, AIE_RESULT);
+    ASSERT_EQ(result, AIE_RESULT);
     AieDlclose(handle);
 }
diff --git a/test/common/encdec/encdec_test.cpp b/test/common/encdec/encdec_test.cpp
index 8876ad4f53a0776ee0a9c109003386a22ed3d701..2fd7914a3c4a1d953424224571cbfc6068aa13e3 100644
--- a/test/common/encdec/encdec_test.cpp
+++ b/test/common/encdec/encdec_test.cpp
@@ -156,7 +156,7 @@ void BasicTypesCheck(bool normalMode = true)
     DataInfo dataInfo {};
     int retCode = EncdecFacade::ProcessEncode(dataInfo, g_int, g_char, g_float, g_long, g_string, g_emptyString);
     MallocPointerGuard<unsigned char> dataInfoGuard(dataInfo.data);
-    EXPECT_EQ(retCode, RETCODE_SUCCESS);
+    ASSERT_EQ(retCode, RETCODE_SUCCESS);
     if (!normalMode) {
         PolluteData(dataInfo);
     }
@@ -170,15 +170,15 @@ void BasicTypesCheck(bool normalMode = true)
     retCode = EncdecFacade::ProcessDecode(dataInfo, outInt, outChar, outFloat, outLong, outString,
         outEmptyString);
     if (normalMode) {
-        EXPECT_EQ(retCode, RETCODE_SUCCESS);
-        EXPECT_TRUE(CompareData(g_int, outInt));
-        EXPECT_TRUE(CompareData(g_char, outChar));
-        EXPECT_TRUE(CompareData(g_float, outFloat));
-        EXPECT_TRUE(CompareData(g_long, outLong));
-        EXPECT_TRUE(CompareData(g_string, outString));
-        EXPECT_TRUE(CompareData(g_emptyString, outEmptyString));
+        ASSERT_EQ(retCode, RETCODE_SUCCESS);
+        ASSERT_TRUE(CompareData(g_int, outInt));
+        ASSERT_TRUE(CompareData(g_char, outChar));
+        ASSERT_TRUE(CompareData(g_float, outFloat));
+        ASSERT_TRUE(CompareData(g_long, outLong));
+        ASSERT_TRUE(CompareData(g_string, outString));
+        ASSERT_TRUE(CompareData(g_emptyString, outEmptyString));
     } else {
-        EXPECT_NE(retCode, RETCODE_SUCCESS);
+        ASSERT_NE(retCode, RETCODE_SUCCESS);
     }
 }
 
@@ -191,7 +191,7 @@ void StructCheck(bool normalMode = true)
 
     int retCode = EncdecFacade::ProcessEncode(dataInfo, structWithPadding, nestedStruct, structWithArray);
     MallocPointerGuard<unsigned char> dataInfoGuard(dataInfo.data);
-    EXPECT_EQ(retCode, RETCODE_SUCCESS);
+    ASSERT_EQ(retCode, RETCODE_SUCCESS);
     if (!normalMode) {
         PolluteData(dataInfo);
     }
@@ -201,12 +201,12 @@ void StructCheck(bool normalMode = true)
 
     retCode = EncdecFacade::ProcessDecode(dataInfo, outStructWithPadding, outNestedStruct, outStructWithArray);
     if (normalMode) {
-        EXPECT_EQ(retCode, RETCODE_SUCCESS);
-        EXPECT_TRUE(CompareData(structWithPadding, outStructWithPadding));
-        EXPECT_TRUE(CompareData(nestedStruct, outNestedStruct));
-        EXPECT_TRUE(CompareData(structWithArray, outStructWithArray));
+        ASSERT_EQ(retCode, RETCODE_SUCCESS);
+        ASSERT_TRUE(CompareData(structWithPadding, outStructWithPadding));
+        ASSERT_TRUE(CompareData(nestedStruct, outNestedStruct));
+        ASSERT_TRUE(CompareData(structWithArray, outStructWithArray));
     } else {
-        EXPECT_NE(retCode, RETCODE_SUCCESS);
+        ASSERT_NE(retCode, RETCODE_SUCCESS);
     }
 }
 
@@ -218,18 +218,18 @@ void StructWithPointerCheck(bool normalMode = true)
         DataInfo dataInfo {};
         int retCode = EncdecFacade::ProcessEncode(dataInfo, structWithPointer);
         MallocPointerGuard<unsigned char> dataInfoGuard(dataInfo.data);
-        EXPECT_EQ(retCode, RETCODE_SUCCESS);
+        ASSERT_EQ(retCode, RETCODE_SUCCESS);
         if (!normalMode) {
             PolluteData(dataInfo);
         }
         StructWithPointer res {};
         retCode = EncdecFacade::ProcessDecode(dataInfo, res);
         if (normalMode) {
-            EXPECT_EQ(retCode, RETCODE_SUCCESS);
-            EXPECT_TRUE(CompareData(structWithPointer, res));
+            ASSERT_EQ(retCode, RETCODE_SUCCESS);
+            ASSERT_TRUE(CompareData(structWithPointer, res));
             ReleaseStructWithPointer(res);
         } else {
-            EXPECT_NE(retCode, RETCODE_SUCCESS);
+            ASSERT_NE(retCode, RETCODE_SUCCESS);
         }
         ReleaseStructWithPointer(structWithPointer);
     }
diff --git a/test/common/event/event_test.cpp b/test/common/event/event_test.cpp
index 61e9a3b3ec6d46a0d8ea6e4cfc3e128cee698654..442563242b031bc158d38685ae71c0cc5307bf62 100644
--- a/test/common/event/event_test.cpp
+++ b/test/common/event/event_test.cpp
@@ -57,8 +57,8 @@ public:
  */
 HWTEST_F(EventTest, EventTest001, TestSize.Level1)
 {
-    EXPECT_TRUE(g_event->Signal());
-    EXPECT_TRUE(g_event->Wait(EVENT_WAIT_TIME_MS));
-    EXPECT_TRUE(g_event->Reset());
-    EXPECT_FALSE(g_event->IsSet());
+    ASSERT_TRUE(g_event->Signal());
+    ASSERT_TRUE(g_event->Wait(EVENT_WAIT_TIME_MS));
+    ASSERT_TRUE(g_event->Reset());
+    ASSERT_FALSE(g_event->IsSet());
 }
diff --git a/test/common/queuepool/queuepool_test.cpp b/test/common/queuepool/queuepool_test.cpp
index 93a15b14c3f346b4862a9ec7e927e273a49cc4cc..32a26c9c522fd43c76fd8c74a992e9892419e4ed 100644
--- a/test/common/queuepool/queuepool_test.cpp
+++ b/test/common/queuepool/queuepool_test.cpp
@@ -84,7 +84,7 @@ HWTEST_F(QueuepoolTest, TestQueuePool003, TestSize.Level1)
     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
     ASSERT_NE(queuePool, nullptr);
     auto busyNum = queuePool->BusyQueueNum();
-    EXPECT_EQ(busyNum, 0);
+    ASSERT_EQ(busyNum, 0);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -102,7 +102,7 @@ HWTEST_F(QueuepoolTest, TestQueuePool004, TestSize.Level1)
     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
     ASSERT_NE(queue, nullptr);
     auto busyNum = queuePool->BusyQueueNum();
-    EXPECT_EQ(busyNum, 1);
+    ASSERT_EQ(busyNum, 1);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -121,7 +121,7 @@ HWTEST_F(QueuepoolTest, TestQueuePool005, TestSize.Level1)
     ASSERT_NE(queue, nullptr);
     queuePool->Push(queue);
     auto busy = queuePool->BusyQueueNum();
-    EXPECT_EQ(busy, 0);
+    ASSERT_EQ(busy, 0);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -160,7 +160,7 @@ HWTEST_F(QueuepoolTest, TestQueuePool007, TestSize.Level1)
     }
 
     queue = queuePool->Pop();
-    EXPECT_EQ(queue, nullptr);
+    ASSERT_EQ(queue, nullptr);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -179,7 +179,7 @@ HWTEST_F(QueuepoolTest, TestQueuePool008, TestSize.Level1)
     std::shared_ptr<Queue<int>> queue;
     queuePool->Push(queue);
     auto busyNum = queuePool->BusyQueueNum();
-    EXPECT_FALSE(busyNum < 0);
+    ASSERT_FALSE(busyNum < 0);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -197,7 +197,7 @@ HWTEST_F(QueuepoolTest, TestQueue001, TestSize.Level1)
     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
 
     bool empty = queue->IsEmpty();
-    EXPECT_TRUE(empty);
+    ASSERT_TRUE(empty);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -218,7 +218,7 @@ HWTEST_F(QueuepoolTest, TestQueue002, TestSize.Level1)
     int iv = TEST_QUEUE_SINGLE_ELEMENT;
     queue->PushBack(iv);
     bool notEmpty = !queue->IsEmpty();
-    EXPECT_TRUE(notEmpty);
+    ASSERT_TRUE(notEmpty);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -239,7 +239,7 @@ HWTEST_F(QueuepoolTest, TestQueue003, TestSize.Level1)
     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
         queue->PushBack(i);
     }
-    EXPECT_TRUE(queue->IsFull());
+    ASSERT_TRUE(queue->IsFull());
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -256,7 +256,7 @@ HWTEST_F(QueuepoolTest, TestQueue004, TestSize.Level1)
     ASSERT_NE(queuePool, nullptr);
     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
     ASSERT_NE(queue, nullptr);
-    EXPECT_FALSE(queue->IsFull());
+    ASSERT_FALSE(queue->IsFull());
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -276,7 +276,7 @@ HWTEST_F(QueuepoolTest, TestQueue005, TestSize.Level1)
 
     int iv = TEST_QUEUE_SINGLE_ELEMENT;
     queue->PushBack(iv);
-    EXPECT_FALSE(queue->IsFull());
+    ASSERT_FALSE(queue->IsFull());
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -296,7 +296,7 @@ HWTEST_F(QueuepoolTest, TestQueue006, TestSize.Level1)
 
     int iv = TEST_QUEUE_SINGLE_ELEMENT;
     int result = queue->PushBack(iv);
-    EXPECT_EQ(result, RETCODE_SUCCESS);
+    ASSERT_EQ(result, RETCODE_SUCCESS);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -317,12 +317,12 @@ HWTEST_F(QueuepoolTest, TestQueue007, TestSize.Level1)
     int result;
     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
         result = queue->PushBack(i);
-        EXPECT_EQ(result, RETCODE_SUCCESS);
+        ASSERT_EQ(result, RETCODE_SUCCESS);
     }
 
     int iv = TEST_QUEUE_SINGLE_ELEMENT;
     result = queue->PushBack(iv);
-    EXPECT_EQ(result, RETCODE_QUEUE_FULL);
+    ASSERT_EQ(result, RETCODE_QUEUE_FULL);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -342,7 +342,7 @@ HWTEST_F(QueuepoolTest, TestQueue008, TestSize.Level1)
 
     int iv;
     int result = queue->PopFront(iv);
-    EXPECT_EQ(result, RETCODE_QUEUE_EMPTY);
+    ASSERT_EQ(result, RETCODE_QUEUE_EMPTY);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -363,8 +363,8 @@ HWTEST_F(QueuepoolTest, TestQueue009, TestSize.Level1)
     int iv = TEST_QUEUE_SINGLE_ELEMENT;
     queue->PushBack(iv);
     int result = queue->PopFront(iv);
-    EXPECT_EQ(result, RETCODE_SUCCESS);
-    EXPECT_EQ(iv, TEST_QUEUE_SINGLE_ELEMENT);
+    ASSERT_EQ(result, RETCODE_SUCCESS);
+    ASSERT_EQ(iv, TEST_QUEUE_SINGLE_ELEMENT);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -385,14 +385,14 @@ HWTEST_F(QueuepoolTest, TestQueue010, TestSize.Level1)
     int result;
     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
         result = queue->PushBack(i);
-        EXPECT_EQ(result, RETCODE_SUCCESS);
+        ASSERT_EQ(result, RETCODE_SUCCESS);
     }
 
     int iv = 0;
     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
         result = queue->PopFront(iv);
-        EXPECT_EQ(result, RETCODE_SUCCESS);
-        EXPECT_EQ(iv, i);
+        ASSERT_EQ(result, RETCODE_SUCCESS);
+        ASSERT_EQ(iv, i);
     }
 
     QueuePool<int>::ReleaseInstance();
@@ -411,7 +411,7 @@ HWTEST_F(QueuepoolTest, TestQueue011, TestSize.Level1)
     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
     ASSERT_NE(queue, nullptr);
     int count = queue->Count();
-    EXPECT_EQ(count, 0);
+    ASSERT_EQ(count, 0);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -435,12 +435,12 @@ HWTEST_F(QueuepoolTest, TestQueue012, TestSize.Level1)
     for (i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
         queue->PushBack(i);
         count = queue->Count();
-        EXPECT_EQ(count, i + 1);
+        ASSERT_EQ(count, i + 1);
     }
 
     queue->PushBack(i);
     count = queue->Count();
-    EXPECT_EQ(count, SINGLE_QUEUE_CAPACITY);
+    ASSERT_EQ(count, SINGLE_QUEUE_CAPACITY);
 
     QueuePool<int>::ReleaseInstance();
 }
@@ -467,12 +467,12 @@ HWTEST_F(QueuepoolTest, TestQueue013, TestSize.Level1)
     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
         queue->PopFront(iv);
         count = queue->Count();
-        EXPECT_EQ(count, SINGLE_QUEUE_CAPACITY - i - 1);
+        ASSERT_EQ(count, SINGLE_QUEUE_CAPACITY - i - 1);
     }
 
     queue->PopFront(iv);
     count = queue->Count();
-    EXPECT_EQ(count, 0);
+    ASSERT_EQ(count, 0);
 
     QueuePool<int>::ReleaseInstance();
 }
diff --git a/test/common/semaphore/semaphore_test.cpp b/test/common/semaphore/semaphore_test.cpp
index 972ed1674fdbac5c61af6de1a4803f25ef1fb70d..a7ee2d89fa61c4415192661a1b18b1a561f78210 100644
--- a/test/common/semaphore/semaphore_test.cpp
+++ b/test/common/semaphore/semaphore_test.cpp
@@ -64,7 +64,7 @@ HWTEST_F(SemaphoreTest, SemaphoreTest001, TestSize.Level1)
     semaphoreExample->Signal();
     sleep(INTERVAL_TIME_S);
     bool ret = semaphoreExample->Wait(WAIT_TIME_MS);
-    EXPECT_TRUE(ret);
+    ASSERT_TRUE(ret);
 }
 
 /**
@@ -83,7 +83,7 @@ HWTEST_F(SemaphoreTest, SimpleNotifierTest001, TestSize.Level1)
     simpleNotifier.AddToBack(itemIn);
     sleep(INTERVAL_TIME_S);
     int ret = simpleNotifier.GetFromFront(TIME_OUT, itemOut);
-    EXPECT_EQ(*itemOut, CONST_VALUE);
-    EXPECT_TRUE(ret);
+    ASSERT_EQ(*itemOut, CONST_VALUE);
+    ASSERT_TRUE(ret);
     AIE_DELETE(itemIn);
 }
diff --git a/test/common/threadpool/thread_pool_test.cpp b/test/common/threadpool/thread_pool_test.cpp
index 9b5dc95cc1ed4b144ce42d7206b8335aa237af2a..f533472c4e63cbac67de3b523462d2953984fdd7 100755
--- a/test/common/threadpool/thread_pool_test.cpp
+++ b/test/common/threadpool/thread_pool_test.cpp
@@ -118,10 +118,10 @@ HWTEST_F(ThreadPoolTest, TestWorker001, TestSize.Level1)
     HILOGD("[Test]Test worker begin");
     CWorker worker;
     worker.Initialize();
-    EXPECT_FALSE(worker.isHung(HUNG_TIME));
-    EXPECT_EQ(worker.GetStackSize(), THREAD_DEFAULT_STACK_SIZE);
-    EXPECT_EQ(worker.Status(), 0);
-    EXPECT_EQ((int)worker.GetThreadId(), INVALID_THREAD_ID);
+    ASSERT_FALSE(worker.isHung(HUNG_TIME));
+    ASSERT_EQ(worker.GetStackSize(), THREAD_DEFAULT_STACK_SIZE);
+    ASSERT_EQ(worker.Status(), 0);
+    ASSERT_EQ((int)worker.GetThreadId(), INVALID_THREAD_ID);
     Thread thread;
     worker.SetThread(&thread);
     HILOGD("[Test]Test worker end, GetThreadId is %lu.", worker.GetThreadId());
@@ -141,14 +141,14 @@ HWTEST_F(ThreadPoolTest, TestThread001, TestSize.Level1)
     HILOGD("[Test]Thread id %lu.", id);
     testThread.SetStackSize(SIZE);
     CWorker worker;
-    EXPECT_TRUE(testThread.StartThread(&worker));
+    ASSERT_TRUE(testThread.StartThread(&worker));
     id = testThread.GetThreadId();
     HILOGD("[Test]Thread id %lu.", id);
-    EXPECT_TRUE(testThread.IsRunning());
-    EXPECT_TRUE(testThread.IsActive());
-    EXPECT_TRUE(testThread.StopThread(STOP_TIME));
-    EXPECT_FALSE(testThread.IsRunning());
-    EXPECT_FALSE(testThread.IsActive());
+    ASSERT_TRUE(testThread.IsRunning());
+    ASSERT_TRUE(testThread.IsActive());
+    ASSERT_TRUE(testThread.StopThread(STOP_TIME));
+    ASSERT_FALSE(testThread.IsRunning());
+    ASSERT_FALSE(testThread.IsActive());
     HILOGD("[Test]Test thread1 end.");
 }
 
@@ -162,9 +162,9 @@ HWTEST_F(ThreadPoolTest, ThreadPoolTest001, TestSize.Level1)
 {
     HILOGD("[Test]ThreadPoolTest001 begin");
     ThreadPool *threadPool = ThreadPool::GetInstance();
-    EXPECT_EQ(threadPool->getStackSize(), 0);
+    ASSERT_EQ(threadPool->getStackSize(), 0);
     threadPool->SetStackSize(SIZE);
-    EXPECT_EQ(threadPool->getStackSize(), SIZE);
+    ASSERT_EQ(threadPool->getStackSize(), SIZE);
     threadPool->SetStackSize(SIZE_MIN);
     HILOGD("[Test]ThreadPoolTest001 end");
 }
@@ -220,7 +220,7 @@ HWTEST_F(ThreadPoolTest, TestThreadWithManyWorker001, TestSize.Level1)
         string tempWorkerName = workerName + to_string(i);
         AIE_NEW(workerList[i], MultiWorker(tempWorkerName));
         threadList[i] = threadPool->Pop();
-        EXPECT_TRUE(threadList[i]->StartThread(workerList[i]));
+        ASSERT_TRUE(threadList[i]->StartThread(workerList[i]));
     }
     for (int i = 0; i < maxThreadNum; i++) {
         threadList[i]->StopThread();
diff --git a/test/common/time/time_test.cpp b/test/common/time/time_test.cpp
index b2ad4fc586a529fa9141ae592652dc293e11c171..fb75e6f5e2b720d13f84e8568fa681125a2ef0a0 100644
--- a/test/common/time/time_test.cpp
+++ b/test/common/time/time_test.cpp
@@ -55,5 +55,5 @@ HWTEST_F(TimeTest, TimeTest001, TestSize.Level1)
     StepSleepMs(SLEEP_TIME);
     time_t curTime = GetCurTimeSec();
     HILOGD("[Test]Second time is %lld", curTime);
-    EXPECT_EQ((curTime - firstTime)*S_TO_MS, SLEEP_TIME);
+    ASSERT_EQ((curTime - firstTime)*S_TO_MS, SLEEP_TIME);
 }
diff --git a/test/function/async_process/async_process_function_test.cpp b/test/function/async_process/async_process_function_test.cpp
index cc0efd718beead026e411f6505589434726ce967..35b366a890f32c1db6f083ed9775b171ea044cd5 100644
--- a/test/function/async_process/async_process_function_test.cpp
+++ b/test/function/async_process/async_process_function_test.cpp
@@ -124,7 +124,7 @@ HWTEST_F(AsyncProcessFunctionTest, TestAieClientAsyncProcess001, TestSize.Level0
     ServiceDeadCb cb = ServiceDeadCb();
     int returnInitCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(returnInitCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo;
     const char *str = INPUT_DATA;
@@ -136,20 +136,20 @@ HWTEST_F(AsyncProcessFunctionTest, TestAieClientAsyncProcess001, TestSize.Level0
     ClientCallback callback = ClientCallback();
     DataInfo outputInfo;
     int returnPrepareCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(returnPrepareCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
-    EXPECT_TRUE(outputInfo.length > 0);
+    ASSERT_EQ(returnPrepareCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+    ASSERT_TRUE(outputInfo.length > 0);
 
     int returnProcessCode = AieClientAsyncProcess(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(returnProcessCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnProcessCode, RETCODE_SUCCESS);
 
     StepSleepMs(WAIT_CALLBACK_TIME_MS);
 
     int returnReleaseCode = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(returnReleaseCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnReleaseCode, RETCODE_SUCCESS);
 
     int returnDestroyCode = AieClientDestroy(clientInfo);
-    EXPECT_EQ(returnDestroyCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnDestroyCode, RETCODE_SUCCESS);
 }
 
 /**
@@ -170,7 +170,7 @@ HWTEST_F(AsyncProcessFunctionTest, TestAieClientAsyncProcess002, TestSize.Level0
     ServiceDeadCb cb = ServiceDeadCb();
     int returnInitCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(returnInitCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo;
     const char *str = INPUT_DATA;
@@ -182,20 +182,20 @@ HWTEST_F(AsyncProcessFunctionTest, TestAieClientAsyncProcess002, TestSize.Level0
     ClientCallback callback = ClientCallback();
     DataInfo outputInfo;
     int returnPrepareCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(returnPrepareCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnPrepareCode, RETCODE_SUCCESS);
 
     inputInfo.data = nullptr;
     inputInfo.length = 0;
 
     int returnProcessCode = AieClientAsyncProcess(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(returnProcessCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnProcessCode, RETCODE_SUCCESS);
 
     StepSleepMs(WAIT_CALLBACK_TIME_MS);
     int returnReleaseCode = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(returnReleaseCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnReleaseCode, RETCODE_SUCCESS);
 
     int returnDestroyCode = AieClientDestroy(clientInfo);
-    EXPECT_EQ(returnDestroyCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnDestroyCode, RETCODE_SUCCESS);
 }
 
 /**
@@ -216,7 +216,7 @@ HWTEST_F(AsyncProcessFunctionTest, TestAieClientAsyncProcess003, TestSize.Level0
     ServiceDeadCb cb = ServiceDeadCb();
     int returnInitCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(returnInitCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo;
     const char *str = INPUT_DATA;
@@ -228,18 +228,18 @@ HWTEST_F(AsyncProcessFunctionTest, TestAieClientAsyncProcess003, TestSize.Level0
     ClientCallback callback = ClientCallback();
     DataInfo outputInfo;
     int returnPrepareCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(returnPrepareCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
-    EXPECT_TRUE(outputInfo.length > 0);
+    ASSERT_EQ(returnPrepareCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+    ASSERT_TRUE(outputInfo.length > 0);
 
     int returnProcessCode = AieClientAsyncProcess(clientInfo, algoInfo, inputInfo);
-    EXPECT_NE(returnProcessCode, RETCODE_SUCCESS);
+    ASSERT_NE(returnProcessCode, RETCODE_SUCCESS);
 
     StepSleepMs(WAIT_CALLBACK_TIME_MS);
 
     int returnReleaseCode = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(returnReleaseCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnReleaseCode, RETCODE_SUCCESS);
 
     int returnDestroyCode = AieClientDestroy(clientInfo);
-    EXPECT_EQ(returnDestroyCode, RETCODE_SUCCESS);
+    ASSERT_EQ(returnDestroyCode, RETCODE_SUCCESS);
 }
diff --git a/test/function/destroy/destroy_function_test.cpp b/test/function/destroy/destroy_function_test.cpp
index 48a997dd02b32bac19aebd972aed41fdd4c67da7..8559a6eb4f43e54d2eb929052dee37ec90b527b4 100644
--- a/test/function/destroy/destroy_function_test.cpp
+++ b/test/function/destroy/destroy_function_test.cpp
@@ -112,11 +112,11 @@ HWTEST_F(DestroyFunctionTest, TestAieClientDestroy001, TestSize.Level0)
     ServiceDeadCb deadCb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &deadCb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
 }
 
 /**
@@ -165,25 +165,25 @@ HWTEST_F(DestroyFunctionTest, TestAieClientDestroy002, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     IClientCb *callback = nullptr;
     DataInfo outputInfo;
     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeSyncProcess = AieClientSyncProcess(clientInfo, algoInfo, inputInfo, outputInfo);
-    EXPECT_EQ(resultCodeSyncProcess, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeSyncProcess, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
 }
 
 /**
@@ -232,25 +232,25 @@ HWTEST_F(DestroyFunctionTest, TestAieClientDestroy003, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     ClientCallback callback = ClientCallback();
     DataInfo outputInfo;
     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeAsyncProcess = AieClientAsyncProcess(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeAsyncProcess, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeAsyncProcess, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
 }
 
 /**
@@ -294,11 +294,11 @@ HWTEST_F(DestroyFunctionTest, TestAieClientDestroy004, TestSize.Level0)
 
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, nullptr);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
 }
 
 /**
@@ -347,19 +347,19 @@ HWTEST_F(DestroyFunctionTest, TestAieClientDestroy005, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     IClientCb *callback = nullptr;
     DataInfo outputInfo;
     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
 }
diff --git a/test/function/init/init_function_test.cpp b/test/function/init/init_function_test.cpp
index 862f4bfca04bd1fec3dbcd246d346f024eff9a82..39cb3a9aa11509b335ce80f5ceecdb7cacbb2361 100644
--- a/test/function/init/init_function_test.cpp
+++ b/test/function/init/init_function_test.cpp
@@ -131,11 +131,11 @@ HWTEST_F(InitFunctionTest, TestAieClientInitConfigInfo001, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initResult = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initResult, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
-    EXPECT_TRUE(clientInfo.sessionId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.sessionId > 0);
 
     int destroyResult = AieClientDestroy(clientInfo);
-    EXPECT_EQ(destroyResult, RETCODE_SUCCESS);
+    ASSERT_EQ(destroyResult, RETCODE_SUCCESS);
 }
 
 /**
@@ -179,11 +179,11 @@ HWTEST_F(InitFunctionTest, TestAieClientInitConfigInfo002, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initResult = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initResult, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
-    EXPECT_TRUE(clientInfo.sessionId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.sessionId > 0);
 
     int destroyResult = AieClientDestroy(clientInfo);
-    EXPECT_EQ(destroyResult, RETCODE_SUCCESS);
+    ASSERT_EQ(destroyResult, RETCODE_SUCCESS);
 }
 
 /**
@@ -227,11 +227,11 @@ HWTEST_F(InitFunctionTest, TestAieClientInitConfigInfo003, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initResult = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initResult, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
-    EXPECT_TRUE(clientInfo.sessionId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.sessionId > 0);
 
     int destroyResult = AieClientDestroy(clientInfo);
-    EXPECT_EQ(destroyResult, RETCODE_SUCCESS);
+    ASSERT_EQ(destroyResult, RETCODE_SUCCESS);
 }
 
 /**
@@ -275,7 +275,7 @@ HWTEST_F(InitFunctionTest, TestAieClientInitClientInfo001, TestSize.Level1)
     ASSERT_EQ(initResult, RETCODE_SUCCESS);
 
     int destroyResult = AieClientDestroy(clientInfo);
-    EXPECT_EQ(destroyResult, RETCODE_SUCCESS);
+    ASSERT_EQ(destroyResult, RETCODE_SUCCESS);
 }
 
 /**
@@ -320,7 +320,7 @@ HWTEST_F(InitFunctionTest, TestAieClientInitAlgoInfo001, TestSize.Level1)
     ASSERT_EQ(initResult, RETCODE_SUCCESS);
 
     int destroyResult = AieClientDestroy(clientInfo);
-    EXPECT_EQ(destroyResult, RETCODE_SUCCESS);
+    ASSERT_EQ(destroyResult, RETCODE_SUCCESS);
 }
 
 /**
@@ -365,5 +365,5 @@ HWTEST_F(InitFunctionTest, TestAieClientInitAlgoInfo002, TestSize.Level1)
     ASSERT_EQ(initResult, RETCODE_SUCCESS);
 
     int destroyResult = AieClientDestroy(clientInfo);
-    EXPECT_EQ(destroyResult, RETCODE_SUCCESS);
+    ASSERT_EQ(destroyResult, RETCODE_SUCCESS);
 }
diff --git a/test/function/plugin_manager/plugin_manager_test.cpp b/test/function/plugin_manager/plugin_manager_test.cpp
index 2e6512551d2aaa4fd5a296da008321f04738376c..e01f584ceda1e56449964d5ce4cf976434ed74b4 100644
--- a/test/function/plugin_manager/plugin_manager_test.cpp
+++ b/test/function/plugin_manager/plugin_manager_test.cpp
@@ -55,12 +55,12 @@ static void TestPluginManager(std::string aid, bool isExceptedLoadPluginSuccess)
     long long version = ALGORITHM_VERSION_VALID;
     std::shared_ptr<Plugin> plugin = nullptr;
     pluginManager->GetPlugin(aid, version, plugin);
-    EXPECT_EQ(isExceptedLoadPluginSuccess, plugin != nullptr) << "pluginManager->GetPlugin test failed.";
+    ASSERT_EQ(isExceptedLoadPluginSuccess, plugin != nullptr) << "pluginManager->GetPlugin test failed.";
 
     if (plugin != nullptr) {
         const char *name = plugin->GetPluginAlgorithm()->GetName();
         HILOGD("[Test]The plugin name [%s].", name);
-        EXPECT_EQ(isExceptedLoadPluginSuccess, name != nullptr) << "Get plugin name failed.";
+        ASSERT_EQ(isExceptedLoadPluginSuccess, name != nullptr) << "Get plugin name failed.";
     }
 
     pluginManager->UnloadPlugin(aid, version);
@@ -147,4 +147,4 @@ HWTEST_F(PluginManagerTest, testPluginManager006, TestSize.Level0)
 {
     HILOGI("[Test]testPluginManager006.");
     TestPluginManagerUnloadPlugin(AID_PLUGIN_INVALID);
-}
\ No newline at end of file
+}
diff --git a/test/function/prepare/prepare_function_test.cpp b/test/function/prepare/prepare_function_test.cpp
index 5bb1e60fc7ddd6ddbc77d4cf450bb4eb02a51a7b..1009e5983945d6171b4184f1da022f688ef6cf06 100644
--- a/test/function/prepare/prepare_function_test.cpp
+++ b/test/function/prepare/prepare_function_test.cpp
@@ -116,7 +116,7 @@ HWTEST_F(PrepareFunctionTest, TestAlgorithmInfo001, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo = {
         .data = (unsigned char*)inputData,
@@ -125,8 +125,12 @@ HWTEST_F(PrepareFunctionTest, TestAlgorithmInfo001, TestSize.Level1)
 
     DataInfo outputInfo;
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, nullptr);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -169,7 +173,7 @@ HWTEST_F(PrepareFunctionTest, TestAlgorithmInfo002, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo = {
         .data = (unsigned char*)inputData,
@@ -182,8 +186,12 @@ HWTEST_F(PrepareFunctionTest, TestAlgorithmInfo002, TestSize.Level1)
     };
     ClientCallback callback = ClientCallback();
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -227,7 +235,7 @@ HWTEST_F(PrepareFunctionTest, TestInputInfo001, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo = {
         .data = nullptr,
@@ -239,8 +247,12 @@ HWTEST_F(PrepareFunctionTest, TestInputInfo001, TestSize.Level1)
         .length = 0
     };
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, nullptr);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -284,7 +296,7 @@ HWTEST_F(PrepareFunctionTest, TestInputInfo002, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo = {
         .data = nullptr,
@@ -297,8 +309,12 @@ HWTEST_F(PrepareFunctionTest, TestInputInfo002, TestSize.Level1)
     };
     ClientCallback callback = ClientCallback();
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -342,7 +358,7 @@ HWTEST_F(PrepareFunctionTest, TestCallback001, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo = {
         .data = (unsigned char*)inputData,
@@ -355,8 +371,12 @@ HWTEST_F(PrepareFunctionTest, TestCallback001, TestSize.Level1)
     };
     ClientCallback callback = ClientCallback();
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -400,7 +420,7 @@ HWTEST_F(PrepareFunctionTest, TestCallback002, TestSize.Level1)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     DataInfo inputInfo = {
         .data = (unsigned char*)inputData,
@@ -412,6 +432,10 @@ HWTEST_F(PrepareFunctionTest, TestCallback002, TestSize.Level1)
         .length = 0
     };
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, nullptr);
-    EXPECT_NE(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo.data, nullptr);
+    ASSERT_NE(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo.data, nullptr);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
diff --git a/test/function/release/release_function_test.cpp b/test/function/release/release_function_test.cpp
index e1ae669f9c94f55f251d294b94a6a724ed58ffc8..836d8f2c8f1bb85776474fd1cd32240efd148691 100755
--- a/test/function/release/release_function_test.cpp
+++ b/test/function/release/release_function_test.cpp
@@ -118,17 +118,19 @@ HWTEST_F(ReleaseFunctionTest, TestAieClientRelease001, TestSize.Level0)
     ServiceDeadCb deadCb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &deadCb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     IClientCb *callback = nullptr;
     DataInfo outputInfo;
     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -178,17 +180,19 @@ HWTEST_F(ReleaseFunctionTest, TestAieClientRelease002, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     ClientCallback callback = ClientCallback();
     DataInfo outputInfo;
     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -238,21 +242,23 @@ HWTEST_F(ReleaseFunctionTest, TestAieClientRelease003, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     IClientCb *callback = nullptr;
     DataInfo outputInfo;
     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeSyncProcess = AieClientSyncProcess(clientInfo, algoInfo, inputInfo, outputInfo);
-    EXPECT_EQ(resultCodeSyncProcess, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeSyncProcess, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -302,19 +308,21 @@ HWTEST_F(ReleaseFunctionTest, TestAieClientRelease004, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     ClientCallback callback = ClientCallback();
     DataInfo outputInfo;
     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeAsyncProcess = AieClientAsyncProcess(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeAsyncProcess, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeAsyncProcess, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_TRUE(clientInfo.clientId > 0);
+
+    AieClientDestroy(clientInfo);
 }
diff --git a/test/function/set_get_option/option_function_test.cpp b/test/function/set_get_option/option_function_test.cpp
index 131a9f07a2d57c489a2489b86d9556ee005e2ef4..c0766c88429a21e1201fb2fea7572a1ed2e0db6d 100755
--- a/test/function/set_get_option/option_function_test.cpp
+++ b/test/function/set_get_option/option_function_test.cpp
@@ -162,7 +162,7 @@ HWTEST_F(OptionFunctionTest, TestOption001, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     const char *str = PREPARE_INPUT_SYNC;
     char *inputData = const_cast<char*>(str);
@@ -183,9 +183,9 @@ HWTEST_F(OptionFunctionTest, TestOption001, TestSize.Level0)
         AIE_NEW(callback, ClientCallback());
     }
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
-    EXPECT_TRUE(outputInfo.length > 0);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+    ASSERT_TRUE(outputInfo.length > 0);
 
     str = SET_OPTION_INPUT;
     inputData = const_cast<char*>(str);
@@ -197,16 +197,20 @@ HWTEST_F(OptionFunctionTest, TestOption001, TestSize.Level0)
     };
     int optionType = 0;
     int setOptionRetCode = AieClientSetOption(clientInfo, optionType, inputInfo);
-    EXPECT_EQ(setOptionRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(setOptionRetCode, RETCODE_SUCCESS);
 
     outputInfo = {
         .data = nullptr,
         .length = 0
     };
     int getRetCode = AieClientGetOption(clientInfo, optionType, inputInfo, outputInfo);
-    EXPECT_EQ(getRetCode, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo.length, inputInfo.length);
+    ASSERT_EQ(getRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo.length, inputInfo.length);
     AIE_DELETE(callback);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -237,7 +241,7 @@ HWTEST_F(OptionFunctionTest, TestOption002, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     const char *str = PREPARE_INPUT_SYNC;
     char *inputData = const_cast<char*>(str);
@@ -257,10 +261,13 @@ HWTEST_F(OptionFunctionTest, TestOption002, TestSize.Level0)
         AIE_NEW(callback, ClientCallback());
     }
 
+    printf("%d!!!!!!!!!!!\n", clientInfo.clientId);
+    fflush(stdout);
+
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
-    EXPECT_NE(outputInfo.data, nullptr);
-    EXPECT_TRUE(outputInfo.length > 0);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(outputInfo.data, nullptr);
+    ASSERT_TRUE(outputInfo.length > 0);
 
     str = SET_OPTION_INPUT;
     inputData = const_cast<char*>(str);
@@ -271,10 +278,10 @@ HWTEST_F(OptionFunctionTest, TestOption002, TestSize.Level0)
     };
     int optionType = 0;
     int setOptionRetCode = AieClientSetOption(clientInfo, optionType, inputInfo);
-    EXPECT_EQ(setOptionRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(setOptionRetCode, RETCODE_SUCCESS);
 
     int getOptionRetCode = AieClientGetOption(clientInfo, optionType, inputInfo, outputInfo);
-    EXPECT_EQ(getOptionRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(getOptionRetCode, RETCODE_SUCCESS);
 
     str = SET_OPTION_DATA;
     inputData = const_cast<char*>(str);
@@ -285,12 +292,16 @@ HWTEST_F(OptionFunctionTest, TestOption002, TestSize.Level0)
     };
 
     int setRetCode = AieClientSetOption(clientInfo, optionType, inputInfo);
-    EXPECT_EQ(setRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(setRetCode, RETCODE_SUCCESS);
 
     int getRetCode = AieClientGetOption(clientInfo, optionType, inputInfo, outputInfo);
-    EXPECT_EQ(getRetCode, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo.length, inputInfo.length);
+    ASSERT_EQ(getRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo.length, inputInfo.length);
     AIE_DELETE(callback);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -321,7 +332,7 @@ HWTEST_F(OptionFunctionTest, TestOption003, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     const char *str = SET_OPTION_INPUT;
     char *inputData = const_cast<char*>(str);
@@ -333,16 +344,20 @@ HWTEST_F(OptionFunctionTest, TestOption003, TestSize.Level0)
     };
     int optionType = 0;
     int setOptionRetCode = AieClientSetOption(clientInfo, optionType, inputInfo);
-    EXPECT_NE(setOptionRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(setOptionRetCode, RETCODE_SUCCESS);
 
     DataInfo outputInfo = {
         .data = nullptr,
         .length = 0
     };
     int getOptionRetCode = AieClientGetOption(clientInfo, optionType, inputInfo, outputInfo);
-    EXPECT_NE(getOptionRetCode, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo.data, nullptr);
-    EXPECT_EQ(outputInfo.length, 0);
+    ASSERT_NE(getOptionRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo.data, nullptr);
+    ASSERT_EQ(outputInfo.length, 0);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -374,7 +389,7 @@ HWTEST_F(OptionFunctionTest, TestOption004, TestSize.Level0)
     ServiceDeadCb cb = ServiceDeadCb();
     int initRetCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
     ASSERT_EQ(initRetCode, RETCODE_SUCCESS);
-    EXPECT_TRUE(clientInfo.clientId > 0);
+    ASSERT_TRUE(clientInfo.clientId > 0);
 
     int optionType = 0;
 
@@ -392,7 +407,11 @@ HWTEST_F(OptionFunctionTest, TestOption004, TestSize.Level0)
         .length = 0
     };
     int getOptionRetCode = AieClientGetOption(clientInfo, optionType, inputInfo, outputInfo);
-    EXPECT_NE(getOptionRetCode, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo.data, nullptr);
-    EXPECT_EQ(outputInfo.length, 0);
+    ASSERT_NE(getOptionRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo.data, nullptr);
+    ASSERT_EQ(outputInfo.length, 0);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
diff --git a/test/function/share_memory/share_memory_test.cpp b/test/function/share_memory/share_memory_test.cpp
index 585abc01831e8ee2b1ac70e75c0d3685554a0435..cbc2d7c686c3d494465cd78312cc2f4e56aa0c6c 100644
--- a/test/function/share_memory/share_memory_test.cpp
+++ b/test/function/share_memory/share_memory_test.cpp
@@ -177,11 +177,11 @@ HWTEST_F(ShareMemoryFunctionTest, TestAieClientShareMemoryInitDestroy, TestSize.
 
     int resultCodeInit = AieClientInit(configInfo_, clientInfo_, algorithmInfo_, &cb_);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo_);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
 }
 
 /**
@@ -196,21 +196,21 @@ HWTEST_F(ShareMemoryFunctionTest, TestAieClientShareMemoryPrepareRelease, TestSi
 
     int resultCodeInit = AieClientInit(configInfo_, clientInfo_, algorithmInfo_, &cb_);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
 
     int resultCodePrepare = AieClientPrepare(clientInfo_, algorithmInfo_, inputInfo_, outputInfo_, nullptr);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo_.length, inputInfo_.length);
-    EXPECT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo_.length, inputInfo_.length);
+    ASSERT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
     FreeDataInfo(&outputInfo_);
 
     DataInfo dummy {};
     int resultCodeRelease = AieClientRelease(clientInfo_, algorithmInfo_, dummy);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo_);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
 }
 
 /**
@@ -225,27 +225,27 @@ HWTEST_F(ShareMemoryFunctionTest, TestAieClientShareMemorySyncProcess, TestSize.
 
     int resultCodeInit = AieClientInit(configInfo_, clientInfo_, algorithmInfo_, &cb_);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
 
     int resultCodePrepare = AieClientPrepare(clientInfo_, algorithmInfo_, inputInfo_, outputInfo_, nullptr);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo_.length, inputInfo_.length);
-    EXPECT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo_.length, inputInfo_.length);
+    ASSERT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
     FreeDataInfo(&outputInfo_);
 
     int resultCodeSyncProcess = AieClientSyncProcess(clientInfo_, algorithmInfo_, inputInfo_, outputInfo_);
-    EXPECT_EQ(resultCodeSyncProcess, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo_.length, inputInfo_.length);
-    EXPECT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
+    ASSERT_EQ(resultCodeSyncProcess, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo_.length, inputInfo_.length);
+    ASSERT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
     FreeDataInfo(&outputInfo_);
 
     DataInfo dummy {};
     int resultCodeRelease = AieClientRelease(clientInfo_, algorithmInfo_, dummy);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo_);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
 }
 
 /**
@@ -260,38 +260,38 @@ HWTEST_F(ShareMemoryFunctionTest, TestAieClientShareMemorySetGetOption, TestSize
 
     int resultCodeInit = AieClientInit(configInfo_, clientInfo_, algorithmInfo_, &cb_);
     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
-    EXPECT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_NE(clientInfo_.clientId, INVALID_CLIENT_ID);
 
     int resultCodePrepare = AieClientPrepare(clientInfo_, algorithmInfo_, inputInfo_, outputInfo_, nullptr);
-    EXPECT_EQ(resultCodePrepare, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo_.length, inputInfo_.length);
-    EXPECT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
+    ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo_.length, inputInfo_.length);
+    ASSERT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
     FreeDataInfo(&outputInfo_);
 
     int dummyOptionType = 0;
     int resultCodeSetOption = AieClientSetOption(clientInfo_, dummyOptionType, inputInfo_);
-    EXPECT_EQ(resultCodeSetOption, RETCODE_SUCCESS);
+    ASSERT_EQ(resultCodeSetOption, RETCODE_SUCCESS);
 
     DataInfo dummy {};
     int resultCodeGetOption = AieClientGetOption(clientInfo_, dummyOptionType, dummy, outputInfo_);
-    EXPECT_EQ(resultCodeGetOption, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo_.length, inputInfo_.length);
-    EXPECT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
+    ASSERT_EQ(resultCodeGetOption, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo_.length, inputInfo_.length);
+    ASSERT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
     FreeDataInfo(&outputInfo_);
 
     resultCodeSetOption = AieClientSetOption(clientInfo_, dummyOptionType, inputInfo_);
-    EXPECT_EQ(resultCodeSetOption, RETCODE_SUCCESS);
+    ASSERT_EQ(resultCodeSetOption, RETCODE_SUCCESS);
 
     resultCodeGetOption = AieClientGetOption(clientInfo_, dummyOptionType, dummy, outputInfo_);
-    EXPECT_EQ(resultCodeGetOption, RETCODE_SUCCESS);
-    EXPECT_EQ(outputInfo_.length, inputInfo_.length);
-    EXPECT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
+    ASSERT_EQ(resultCodeGetOption, RETCODE_SUCCESS);
+    ASSERT_EQ(outputInfo_.length, inputInfo_.length);
+    ASSERT_EQ(memcmp(outputInfo_.data, inputInfo_.data, inputInfo_.length), 0);
     FreeDataInfo(&outputInfo_);
 
     int resultCodeRelease = AieClientRelease(clientInfo_, algorithmInfo_, dummy);
-    EXPECT_EQ(resultCodeRelease, RETCODE_SUCCESS);
+    ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
 
     int resultCodeDestroy = AieClientDestroy(clientInfo_);
-    EXPECT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
-    EXPECT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
+    ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
+    ASSERT_EQ(clientInfo_.clientId, INVALID_CLIENT_ID);
 }
diff --git a/test/function/sync_process/sync_process_function_test.cpp b/test/function/sync_process/sync_process_function_test.cpp
index 9c2ff1881e90dda2f220885751044d4ec8642b4c..1a48688fc9b5d51bdc40e8351d0e8c29e834673e 100755
--- a/test/function/sync_process/sync_process_function_test.cpp
+++ b/test/function/sync_process/sync_process_function_test.cpp
@@ -134,14 +134,18 @@ HWTEST_F(SyncProcessFunctionTest, TestAieClientSyncProcess001, TestSize.Level0)
         .length = 0,
     };
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, nullptr);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
 
     outputInfo = {
         .data = nullptr,
         .length = 0,
     };
     int processRetCode = AieClientSyncProcess(clientInfo, algoInfo, inputInfo, outputInfo);
-    EXPECT_EQ(processRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(processRetCode, RETCODE_SUCCESS);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -196,7 +200,7 @@ HWTEST_F(SyncProcessFunctionTest, TestAieClientSyncProcess002, TestSize.Level0)
     };
 
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, prepareInputInfo, outputInfo, nullptr);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
 
     outputInfo = {
         .data = nullptr,
@@ -209,7 +213,11 @@ HWTEST_F(SyncProcessFunctionTest, TestAieClientSyncProcess002, TestSize.Level0)
     };
 
     int processRetCode = AieClientSyncProcess(clientInfo, algoInfo, processInputInfo, outputInfo);
-    EXPECT_EQ(processRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(processRetCode, RETCODE_SUCCESS);
+
+    AieClientRelease(clientInfo, algoInfo, processInputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -264,7 +272,7 @@ HWTEST_F(SyncProcessFunctionTest, TestAieClientSyncProcess003, TestSize.Level0)
     };
     ClientCallback callback = ClientCallback();
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
 
     outputInfo = {
         .data = nullptr,
@@ -272,7 +280,11 @@ HWTEST_F(SyncProcessFunctionTest, TestAieClientSyncProcess003, TestSize.Level0)
     };
 
     int processRetCode = AieClientSyncProcess(clientInfo, algoInfo, inputInfo, outputInfo);
-    EXPECT_NE(processRetCode, RETCODE_SUCCESS);
+    ASSERT_NE(processRetCode, RETCODE_SUCCESS);
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
 
 /**
@@ -311,11 +323,15 @@ HWTEST_F(SyncProcessFunctionTest, TestAieClientSyncProcess004, TestSize.Level0)
     };
 
     int prepareRetCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, nullptr);
-    EXPECT_EQ(prepareRetCode, RETCODE_SUCCESS);
+    ASSERT_EQ(prepareRetCode, RETCODE_SUCCESS);
 
     for (int i = 0; i < CYCLENUMS; ++i) {
         HILOGI("[Test]CycleNum is [%d]", i);
         int processRetCode = AieClientSyncProcess(clientInfo, algoInfo, inputInfo, outputInfo);
-        EXPECT_EQ(processRetCode, RETCODE_SUCCESS);
+        ASSERT_EQ(processRetCode, RETCODE_SUCCESS);
     }
+
+    AieClientRelease(clientInfo, algoInfo, inputInfo);
+
+    AieClientDestroy(clientInfo);
 }
diff --git a/test/performance/delay/async_process/async_process_delay_test.cpp b/test/performance/delay/async_process/async_process_delay_test.cpp
index 620e4a8a86158fcdb98326196f9cdffe3e2cfd40..ac72bbef81349ce07b55508190558e59c4751201 100644
--- a/test/performance/delay/async_process/async_process_delay_test.cpp
+++ b/test/performance/delay/async_process/async_process_delay_test.cpp
@@ -131,49 +131,49 @@ static void CheckTimeInit()
 {
     std::time_t duration = g_initTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimeInit][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_INIT_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_INIT_TIME));
 }
 
 static void CheckTimePrepare()
 {
     std::time_t duration = g_prepareTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimePrepare][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_PREPARE_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_PREPARE_TIME));
 }
 
 static void CheckTimeAsyncProcess()
 {
     std::time_t duration = g_processTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimeAsyncProcess][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_ASYNC_PROCESS_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_ASYNC_PROCESS_TIME));
 }
 
 static void CheckTimeRelease()
 {
     std::time_t duration = g_releaseTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimeRelease][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_RELEASE_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_RELEASE_TIME));
 }
 
 static void CheckTimeDestroy()
 {
     std::time_t duration = g_destroyTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimeDestroy][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_DESTROY_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_DESTROY_TIME));
 }
 
 static void CheckTimeSetOption()
 {
     std::time_t duration = g_setOptionTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimeSetOption][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_SETOPTION_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_SETOPTION_TIME));
 }
 
 static void CheckTimeGetOption()
 {
     std::time_t duration = g_getOptionTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimeGetOption][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_GETOPTION_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_GETOPTION_TIME));
 }
 
 /**
diff --git a/test/performance/delay/sync_process/sync_process_delay_test.cpp b/test/performance/delay/sync_process/sync_process_delay_test.cpp
index bfe9a9c039bfdd4f8fe58cd405afdd00113726bd..00477f381f2131b186f2c0a5d0137e0858a9d3e6 100644
--- a/test/performance/delay/sync_process/sync_process_delay_test.cpp
+++ b/test/performance/delay/sync_process/sync_process_delay_test.cpp
@@ -181,5 +181,5 @@ HWTEST_F(SyncProcessTimeTest, TestSyncTime001, TestSize.Level0)
     }
     std::time_t duration = processTotalTime / EXECUTE_TIMES;
     HILOGI("[Test][CheckTimeSyncProcess][%lld]", duration);
-    EXPECT_TRUE((duration > 0) && (duration <= EXCEPTED_SYNC_PROCESS_TIME));
+    ASSERT_TRUE((duration > 0) && (duration <= EXCEPTED_SYNC_PROCESS_TIME));
 }
diff --git a/test/performance/reliability/aie_client/aie_client_reliability_test.cpp b/test/performance/reliability/aie_client/aie_client_reliability_test.cpp
index 392eb108e84a493c6d21a1583be801e5f313eeaa..f91cf46602573266df750b8676e49afa609a6272 100644
--- a/test/performance/reliability/aie_client/aie_client_reliability_test.cpp
+++ b/test/performance/reliability/aie_client/aie_client_reliability_test.cpp
@@ -131,23 +131,23 @@ HWTEST_F(AieClientReliabilityTest, AieClientSyncReliabilityTest001, TestSize.Lev
 
         ServiceDeadCb cb;
         int resultCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         DataInfo outputInfo;
 
         resultCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, nullptr);
         FreeDataInfo(outputInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         resultCode = AieClientSyncProcess(clientInfo, algoInfo, inputInfo, outputInfo);
         FreeDataInfo(outputInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         resultCode = AieClientRelease(clientInfo, algoInfo, inputInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         resultCode = AieClientDestroy(clientInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         time_t currentTime = GetCurTimeSec();
         if ((currentTime - asyncStart) >= TIME_TEST) {
@@ -203,24 +203,24 @@ HWTEST_F(AieClientReliabilityTest, AieClientAsyncReliabilityTest001, TestSize.Le
 
         ServiceDeadCb cb;
         int resultCode = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         ClientCallback callback;
 
         DataInfo outputInfo;
         resultCode = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
         FreeDataInfo(outputInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         resultCode = AieClientAsyncProcess(clientInfo, algoInfo, inputInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
         StepSleepMs(500);
 
         resultCode = AieClientRelease(clientInfo, algoInfo, inputInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         resultCode = AieClientDestroy(clientInfo);
-        EXPECT_EQ(resultCode, RETCODE_SUCCESS);
+        ASSERT_EQ(resultCode, RETCODE_SUCCESS);
 
         time_t currentTime = GetCurTimeSec();
         if ((currentTime - asyncStart) >= TIME_TEST) {