diff --git a/tests/unittests/backup_ext/ext_extension_stub_test.cpp b/tests/unittests/backup_ext/ext_extension_stub_test.cpp
index fece588ece4eb3bf002a606c66e4f70b89629bf4..57eec9cee02c64edf857660bdd8a3bb679c95873 100644
--- a/tests/unittests/backup_ext/ext_extension_stub_test.cpp
+++ b/tests/unittests/backup_ext/ext_extension_stub_test.cpp
@@ -87,6 +87,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0
         MessageParcel reply;
         MessageOption option;
         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(u16string()));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->OnRemoteRequest(code, data, reply, option);
         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
 
@@ -123,6 +124,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdGetFileHandle(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
 
@@ -169,6 +171,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleClear_01
         MessageParcel reply;
         EXPECT_CALL(*stub, HandleClear()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdHandleClear(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
@@ -200,6 +203,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0
         MessageParcel reply;
         EXPECT_CALL(*stub, HandleBackup()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdHandleBackup(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
@@ -230,6 +234,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishFile_01
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdPublishFile(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
 
@@ -268,6 +273,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_
         MessageParcel reply;
         EXPECT_CALL(*stub, HandleRestore()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdHandleRestore(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
@@ -299,6 +305,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncremental
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdGetIncrementalFileHandle(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
 
@@ -337,6 +344,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishIncreme
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdPublishIncrementalFile(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
 
@@ -377,6 +385,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleIncremen
         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(0));
         EXPECT_CALL(*stub, HandleIncrementalBackup(_, _)).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdHandleIncrementalBackup(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
@@ -410,6 +419,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnB
         MessageParcel reply;
         EXPECT_CALL(*stub, IncrementalOnBackup()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdIncrementalOnBackup(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
@@ -444,6 +454,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncremental
         EXPECT_CALL(*stub, GetIncrementalBackupFileHandle())
             .WillOnce(Return(std::tuple<UniqueFd, UniqueFd>(UniqueFd(-1), UniqueFd(-1))));
         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdGetIncrementalBackupFileHandle(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
@@ -483,6 +494,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_
         MessageParcel reply;
         EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdGetBackupInfo(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
@@ -520,6 +532,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(stub, nullptr);
         auto err = stub->CmdUpdateFdSendRate(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
 
diff --git a/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp b/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp
index 1e7a939e88649fe40565187b6b6fea8ec5332459..ce3c82b040188a8049bc45185e9742cb41eb63a1 100644
--- a/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp
@@ -77,7 +77,8 @@ void SchedSchedulerTest::Init(IServiceReverse::Scenario scenario)
     };
     transform(bundleNames.begin(), bundleNames.end(), inserter(backupExtNameMap, backupExtNameMap.end()),
               setBackupExtNameMap);
-
+              
+    EXPECT_NE(sessionManagerPtr_, nullptr);
     sessionManagerPtr_->Active({
         .clientToken = CLIENT_TOKEN_ID,
         .scenario = scenario,
@@ -99,6 +100,7 @@ HWTEST_F(SchedSchedulerTest, SUB_Service_Sched_0100, testing::ext::TestSize.Leve
     GTEST_LOG_(INFO) << "SchedSchedulerTest-begin SUB_Service_Sched_0100";
     try {
         Init(IServiceReverse::Scenario::BACKUP);
+        EXPECT_NE(schedPtr_, nullptr);
         schedPtr_->Sched();
         GTEST_LOG_(INFO) << "SchedSchedulerTest-Sched Branches";
         sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::FINISH);
@@ -132,6 +134,8 @@ HWTEST_F(SchedSchedulerTest, SUB_Service_ExecutingQueueTasks_0100, testing::ext:
 {
     GTEST_LOG_(INFO) << "SchedSchedulerTest-begin SUB_Service_ExecutingQueueTasks_0100";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
+        EXPECT_NE(schedPtr_, nullptr);
         sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::START);
         schedPtr_->ExecutingQueueTasks(BUNDLE_NAME);
         sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::RUNNING);
@@ -156,6 +160,7 @@ HWTEST_F(SchedSchedulerTest, SUB_Service_RemoveExtConn_0100, testing::ext::TestS
 {
     GTEST_LOG_(INFO) << "SchedSchedulerTest-begin SUB_Service_RemoveExtConn_0100";
     try {
+        EXPECT_NE(schedPtr_, nullptr);
         schedPtr_->RemoveExtConn("test");
     } catch (...) {
         EXPECT_TRUE(false);
diff --git a/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp b/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp
index b62582c468526f5144acc824f23e2f1cbb9cca26..85c59577088e5e2840f24ead26416c0b9e1c3f5c 100644
--- a/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp
@@ -45,6 +45,7 @@ public:
     static void TearDownTestCase();
     void SetUp() override {};
     void TearDown() override {};
+
 public:
     static inline shared_ptr<ServiceReverseProxy> proxy_ = nullptr;
     static inline sptr<ServiceReverseMock> mock_ = nullptr;
@@ -91,6 +92,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
         TestManager tm("ServiceReverseProxyTest_GetFd_0100");
         std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
         UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, fd, 0);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -115,6 +117,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -124,6 +127,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -133,6 +137,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -143,6 +148,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -173,6 +179,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -184,6 +191,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -196,6 +204,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -228,6 +237,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010
             EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
             EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -259,6 +269,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -283,6 +294,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -292,6 +304,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -302,6 +315,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -313,6 +327,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
             EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -344,6 +359,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinishe
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -368,6 +384,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinishe
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -430,6 +447,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
         EXPECT_TRUE(true);
     } catch (...) {
@@ -456,6 +474,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -506,6 +525,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnResultReport_
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
         std::string bundleName = "app01";
+        EXPECT_NE(proxy_, nullptr);
         proxy_->BackupOnResultReport(RESULT_REPORT, bundleName);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -531,6 +551,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnResultReport_
         std::string bundleName = "app01";
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->BackupOnResultReport(RESULT_REPORT, bundleName);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -590,6 +611,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarte
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -614,6 +636,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarte
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -675,6 +698,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinish
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -699,6 +723,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinish
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -761,6 +786,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
         EXPECT_TRUE(true);
     } catch (...) {
@@ -787,6 +813,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -847,6 +874,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_01
         if (fd < 0) {
             errCode = BError::GetCodeByErrno(errno);
         }
+        EXPECT_NE(proxy_, nullptr);
         proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, fd, errCode);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -871,6 +899,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_01
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -918,6 +947,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_01
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -971,6 +1001,7 @@ HWTEST_F(ServiceReverseProxyTest,
         TestManager tm1("ServiceReverseProxyTest_GetFd_0301");
         std::string manifestFilePath = tm1.GetRootDirCurTest().append(FILE_NAME_MANIFEST);
         UniqueFd manifestFd(open(manifestFilePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, fd, manifestFd, 0);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -997,6 +1028,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1046,6 +1078,7 @@ HWTEST_F(ServiceReverseProxyTest,
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1100,6 +1133,7 @@ HWTEST_F(ServiceReverseProxyTest,
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1158,6 +1192,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1184,6 +1219,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1247,6 +1283,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1273,6 +1310,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1315,7 +1353,6 @@ HWTEST_F(ServiceReverseProxyTest,
     GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101";
 }
 
-
 /**
  * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100
  * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100
@@ -1337,6 +1374,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1365,6 +1403,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1418,6 +1457,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1444,6 +1484,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1486,7 +1527,6 @@ HWTEST_F(ServiceReverseProxyTest,
     GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101";
 }
 
-
 /**
  * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100
  * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100
@@ -1509,6 +1549,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1536,6 +1577,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1599,6 +1641,7 @@ HWTEST_F(ServiceReverseProxyTest,
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1627,6 +1670,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1689,6 +1733,7 @@ HWTEST_F(ServiceReverseProxyTest,
         TestManager tm1("ServiceReverseProxyTest_GetFd_0401");
         std::string manifestFilePath = tm1.GetRootDirCurTest().append(FILE_NAME_MANIFEST);
         UniqueFd manifestFd(open(manifestFilePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, fd, manifestFd, 0);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1715,6 +1760,7 @@ HWTEST_F(ServiceReverseProxyTest,
     try {
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1775,6 +1821,7 @@ HWTEST_F(ServiceReverseProxyTest,
             EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1830,6 +1877,7 @@ HWTEST_F(ServiceReverseProxyTest,
             EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
             EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1874,6 +1922,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnResultReport
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
         std::string bundleName = "app01";
+        EXPECT_NE(proxy_, nullptr);
         proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1899,6 +1948,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnResultReport
         std::string bundleName = "app01";
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -1959,6 +2009,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnR
             .Times(1)
             .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
         std::string bundleName = "app01";
+        EXPECT_NE(proxy_, nullptr);
         proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName);
         EXPECT_TRUE(true);
     } catch (...) {
@@ -1985,6 +2036,7 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnR
         std::string bundleName = "app01";
         try {
             EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+            EXPECT_NE(proxy_, nullptr);
             proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName);
             EXPECT_TRUE(false);
         } catch (BError &err) {
diff --git a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp
index 71765843ca8f57cf54fd9d7ed459fb573523eefa..2a8f6eb2db9d5c4a3fafec07ef3291cd3fb8d730 100644
--- a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp
@@ -131,6 +131,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_OnRemoteRequest_0100, testin
         MessageParcel reply;
         MessageOption option;
         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(u16string()));
+        EXPECT_NE(service, nullptr);
         auto err = service->OnRemoteRequest(0, data, reply, option);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -167,6 +168,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitRestoreSession_0100, tes
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdInitRestoreSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -211,6 +213,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitBackupSession_0100, test
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdInitBackupSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -256,6 +259,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Start_0100, testing::ext::Te
         MessageParcel reply;
         EXPECT_CALL(*service, Start()).WillOnce(Return(BError(BError::Codes::OK)));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdStart(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
@@ -287,6 +291,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100, t
         MessageParcel reply;
         EXPECT_CALL(*service, GetLocalCapabilities()).WillOnce(Return(UniqueFd(0)));
         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdGetLocalCapabilities(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
@@ -317,6 +322,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishFile_0100, testing::e
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdPublishFile(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
@@ -358,6 +364,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0100, testing::
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppFileReady(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -410,6 +417,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0101, testing::
         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
         EXPECT_CALL(*service, AppFileReady(_, _, _)).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
+        EXPECT_NE(service, nullptr);
         auto ret = service->CmdAppFileReady(data, reply);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -435,6 +443,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppDone_0100, testing::ext::
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadBool(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppDone(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -472,6 +481,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetFileHandle_0100, testing:
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdGetFileHandle(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -506,6 +516,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesRestoreSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -544,6 +555,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_
         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesRestoreSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -579,6 +591,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_
         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
+        EXPECT_NE(service, nullptr);
         EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _)).WillOnce(Return(BError(BError::Codes::OK)));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
         auto ret = service->CmdAppendBundlesRestoreSession(data, reply);
@@ -606,6 +619,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesBackupSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -642,6 +656,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Finish_0100, testing::ext::T
     try {
         MessageParcel data;
         MessageParcel reply;
+        EXPECT_NE(service, nullptr);
         EXPECT_CALL(*service, Finish()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
         auto err = service->CmdFinish(data, reply);
@@ -673,6 +688,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Release_0100, testing::ext::
     try {
         MessageParcel data;
         MessageParcel reply;
+        EXPECT_NE(service, nullptr);
         EXPECT_CALL(*service, Release()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
         auto err = service->CmdRelease(data, reply);
@@ -705,6 +721,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetBackupInfo_0100, testing:
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdGetBackupInfo(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
@@ -747,6 +764,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_UpdateTimer_0100, testing::e
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdUpdateTimer(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
@@ -784,6 +802,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreS
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -828,6 +847,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreS
         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -870,6 +890,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSe
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesDetailsBackupSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -911,6 +932,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremen
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdGetLocalCapabilitiesIncremental(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -953,6 +975,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitIncrementalBackupSession
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdInitIncrementalBackupSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -998,6 +1021,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBack
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesIncrementalBackupSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -1041,6 +1065,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBack
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppendBundlesDetailsIncrementalBackupSession(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -1085,6 +1110,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100,
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdPublishIncrementalFile(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
@@ -1126,6 +1152,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_010
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdPublishSAIncrementalFile(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
 
@@ -1169,6 +1196,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppIncrementalFileReady(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -1218,6 +1246,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(false));
         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
+        EXPECT_NE(service, nullptr);
         EXPECT_CALL(*service, AppIncrementalFileReady(_, _, _, _)).WillOnce(Return(0));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
         auto ret = service->CmdAppIncrementalFileReady(data, reply);
@@ -1245,6 +1274,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalDone_0100, tes
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdAppIncrementalDone(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
@@ -1282,6 +1312,7 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_010
         MessageParcel data;
         MessageParcel reply;
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
+        EXPECT_NE(service, nullptr);
         auto err = service->CmdGetIncrementalFileHandle(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
 
diff --git a/tests/unittests/backup_sa/module_ipc/service_test.cpp b/tests/unittests/backup_sa/module_ipc/service_test.cpp
index fb14e645938bb4d9f5181dd3b08df16ed1e2525a..1a3175fbcd1fe433c0d50ef2e301b989f75c1ce0 100644
--- a/tests/unittests/backup_sa/module_ipc/service_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_test.cpp
@@ -80,6 +80,8 @@ ErrCode ServiceTest::Init(IServiceReverse::Scenario scenario)
     detailInfos.emplace_back(json);
     ErrCode ret = 0;
     if (scenario == IServiceReverse::Scenario::RESTORE) {
+        EXPECT_NE(servicePtr_, nullptr);
+        EXPECT_NE(remote_, nullptr);
         UniqueFd fd = servicePtr_->GetLocalCapabilities();
         EXPECT_GE(fd, BError(BError::Codes::OK));
         ret = servicePtr_->InitRestoreSession(remote_);
@@ -112,6 +114,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilities_0100, testing::ext::TestS
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetLocalCapabilities_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         UniqueFd fd = servicePtr_->GetLocalCapabilities();
         EXPECT_GT(fd, BError(BError::Codes::OK));
     } catch (...) {
@@ -134,6 +137,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilities_0101, testing::ext::TestS
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetLocalCapabilities_0101";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         UniqueFd fd = servicePtr_->GetLocalCapabilities();
         EXPECT_GT(fd, -EPERM);
     } catch (...) {
@@ -156,6 +160,7 @@ HWTEST_F(ServiceTest, SUB_Service_OnStart_0100, testing::ext::TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStart_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->OnStart();
     } catch (...) {
         EXPECT_TRUE(false);
@@ -177,6 +182,7 @@ HWTEST_F(ServiceTest, SUB_Service_Start_0100, testing::ext::TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_Start_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         auto ret = servicePtr_->Start();
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -202,6 +208,7 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0100, testing::ext::TestSize.Level
         ErrCode ret = Init(IServiceReverse::Scenario::RESTORE);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         BFileInfo fileInfo {BUNDLE_NAME, "", 0};
+        EXPECT_NE(servicePtr_, nullptr);
         ret = servicePtr_->PublishFile(fileInfo);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         GTEST_LOG_(INFO) << "ServiceTest-PublishFile Branches";
@@ -231,6 +238,7 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0101, testing::ext::TestSize.Level
         ErrCode ret = Init(IServiceReverse::Scenario::RESTORE);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         BFileInfo fileInfo {BUNDLE_NAME, "", 0};
+        EXPECT_NE(servicePtr_, nullptr);
         ret = servicePtr_->PublishFile(fileInfo);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         GTEST_LOG_(INFO) << "ServiceTest-PublishFile Branches";
@@ -260,6 +268,7 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0102, testing::ext::TestSize.Level
         ErrCode ret = Init(IServiceReverse::Scenario::RESTORE);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         BFileInfo fileInfo {BUNDLE_NAME, "", 0};
+        EXPECT_NE(servicePtr_, nullptr);
         ret = servicePtr_->PublishFile(fileInfo);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -283,6 +292,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppFileReady_0100, testing::ext::TestSize.Leve
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppFileReady_0100";
     try {
         string fileName = MANAGE_JSON;
+        EXPECT_NE(servicePtr_, nullptr);
         auto ret = servicePtr_->AppFileReady(fileName, UniqueFd(-1), 0);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         GTEST_LOG_(INFO) << "ServiceTest-AppFileReady Branches";
@@ -310,6 +320,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppFileReady_0101, testing::ext::TestSize.Leve
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppFileReady_0101";
     try {
         string fileName = "";
+        EXPECT_NE(servicePtr_, nullptr);
         auto ret = servicePtr_->AppFileReady(fileName, UniqueFd(-1), 0);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -333,6 +344,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppFileReady_0102, testing::ext::TestSize.Leve
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppFileReady_0102";
     try {
         string fileName = "manage.json";
+        EXPECT_NE(servicePtr_, nullptr);
         auto ret = servicePtr_->AppFileReady(fileName, UniqueFd(-1), 0);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -356,6 +368,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0100, testing::ext::TestSize.Level1)
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppDone_0100";
     try {
         GTEST_LOG_(INFO) << "SUB_Service_AppDone Branches Start";
+        EXPECT_NE(servicePtr_, nullptr);
         auto ret = servicePtr_->AppDone(BError(BError::Codes::OK));
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         GTEST_LOG_(INFO) << "SUB_Service_AppDone_0100 BACKUP";
@@ -388,6 +401,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0101, testing::ext::TestSize.Level1)
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_AppDone_0101";
     try {
         GTEST_LOG_(INFO) << "SUB_Service_AppDone Branches Start";
+        EXPECT_NE(servicePtr_, nullptr);
         auto ret = servicePtr_->AppDone(BError(BError::Codes::OK));
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         GTEST_LOG_(INFO) << "SUB_Service_AppDone_0101 RESTORE";
@@ -417,6 +431,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0102, testing::ext::TestSize.Level1)
     try {
         GTEST_LOG_(INFO) << "SUB_Service_AppDone Branches Start";
         string bundleName = "";
+        EXPECT_NE(servicePtr_, nullptr);
         auto ret = servicePtr_->AppDone(BError(BError::Codes::OK));
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -442,6 +457,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0100, testing::ext::Test
         GTEST_LOG_(INFO) << "SUB_Service_LaunchBackupExtension_0100 RESTORE";
         ErrCode ret = Init(IServiceReverse::Scenario::RESTORE);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
+        EXPECT_NE(servicePtr_, nullptr);
         ret = servicePtr_->LaunchBackupExtension(BUNDLE_NAME);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         GTEST_LOG_(INFO) << "SUB_Service_LaunchBackupExtension_0100 BACKUP";
@@ -472,6 +488,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0101, testing::ext::Test
         GTEST_LOG_(INFO) << "SUB_Service_LaunchBackupExtension_0100 UNDEFINED";
         ErrCode ret = Init(IServiceReverse::Scenario::UNDEFINED);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
+        EXPECT_NE(servicePtr_, nullptr);
         ret = servicePtr_->LaunchBackupExtension(BUNDLE_NAME);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -496,6 +513,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetFileHandle_0100, testing::ext::TestSize.Lev
     try {
         ErrCode ret = Init(IServiceReverse::Scenario::RESTORE);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
+        EXPECT_NE(servicePtr_, nullptr);
         ret = servicePtr_->GetFileHandle(BUNDLE_NAME, FILE_NAME);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
     } catch (...) {
@@ -522,6 +540,7 @@ HWTEST_F(ServiceTest, SUB_Service_OnBackupExtensionDied_0100, testing::ext::Test
         ErrCode ret = Init(IServiceReverse::Scenario::RESTORE);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
         string bundleName = BUNDLE_NAME;
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->OnBackupExtensionDied(move(bundleName));
         GTEST_LOG_(INFO) << "SUB_Service_OnBackupExtensionDied_0100 BACKUP";
         ret = Init(IServiceReverse::Scenario::BACKUP);
@@ -551,6 +570,7 @@ HWTEST_F(ServiceTest, SUB_Service_ExtStart_0100, testing::ext::TestSize.Level1)
         GTEST_LOG_(INFO) << "SUB_Service_ExtStart_0100 BACKUP";
         ErrCode ret = Init(IServiceReverse::Scenario::BACKUP);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->ExtStart(BUNDLE_NAME);
         GTEST_LOG_(INFO) << "ServiceTest-ExtStart BACKUP Branches";
         servicePtr_->ExtStart(BUNDLE_NAME);
@@ -577,6 +597,7 @@ HWTEST_F(ServiceTest, SUB_Service_Dump_0100, testing::ext::TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_Dump_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->Dump(-1, {});
         TestManager tm("ServiceTest_GetFd_0100");
         string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
@@ -602,6 +623,7 @@ HWTEST_F(ServiceTest, SUB_Service_Dump_0101, testing::ext::TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_Dump_0101";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         int ret = servicePtr_->Dump(1, {});
         EXPECT_EQ(ret, 0);
     } catch (...) {
@@ -624,6 +646,7 @@ HWTEST_F(ServiceTest, SUB_Service_Dump_0102, testing::ext::TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_Dump_0102";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         int ret = servicePtr_->Dump(-1, {});
         EXPECT_EQ(ret, -1);
     } catch (...) {
@@ -649,6 +672,7 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectFailed_0100, testing::ext::TestSize.
         GTEST_LOG_(INFO) << "SUB_Service_ExtConnectFailed_0100 RESTORE";
         ErrCode ret = Init(IServiceReverse::Scenario::RESTORE);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->ExtConnectFailed(BUNDLE_NAME, BError(BError::Codes::OK));
         GTEST_LOG_(INFO) << "SUB_Service_ExtConnectFailed_0100 BACKUP";
         ret = Init(IServiceReverse::Scenario::BACKUP);
@@ -674,6 +698,7 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectDone_0100, testing::ext::TestSize.Le
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtConnectDone_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->ExtConnectDone(BUNDLE_NAME);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -697,6 +722,7 @@ HWTEST_F(ServiceTest, SUB_Service_StopAll_0100, testing::ext::TestSize.Level1)
     try {
         SvcSessionManager::Impl impl_;
         impl_.clientToken = 0;
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->StopAll(nullptr, true);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -720,6 +746,7 @@ HWTEST_F(ServiceTest, SUB_Service_StopAll_0101, testing::ext::TestSize.Level1)
     try {
         SvcSessionManager::Impl impl_;
         impl_.clientProxy = nullptr;
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->StopAll(nullptr, true);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -743,6 +770,7 @@ HWTEST_F(ServiceTest, SUB_Service_StopAll_0102, testing::ext::TestSize.Level1)
     try {
         SvcSessionManager::Impl impl_;
         impl_.clientToken = 0;
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->StopAll(nullptr, false);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -766,6 +794,7 @@ HWTEST_F(ServiceTest, SUB_Service_StopAll_0103, testing::ext::TestSize.Level1)
     try {
         SvcSessionManager::Impl impl_;
         impl_.clientProxy = nullptr;
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->StopAll(nullptr, false);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -790,6 +819,7 @@ HWTEST_F(ServiceTest, SUB_Service_StopAll_0104, testing::ext::TestSize.Level1)
         SvcSessionManager::Impl impl_;
         impl_.clientProxy = nullptr;
         const wptr<IRemoteObject> obj = nullptr;
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->StopAll(obj, false);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -811,6 +841,7 @@ HWTEST_F(ServiceTest, SUB_Service_OnStop_0100, testing::ext::TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStop_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->OnStop();
     } catch (...) {
         EXPECT_TRUE(false);
@@ -832,6 +863,7 @@ HWTEST_F(ServiceTest, SUB_Service_SendStartAppGalleryNotify_0100, testing::ext::
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendStartAppGalleryNotify_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         BundleName bundleName = "";
         servicePtr_->SendStartAppGalleryNotify(bundleName);
     } catch (...) {
@@ -854,6 +886,7 @@ HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0100, testing::ext::TestSize.L
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SessionDeactive_0100";
     try {
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->SessionDeactive();
     } catch (...) {
         EXPECT_TRUE(false);
@@ -879,6 +912,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetBackupInfo_0100, testing::ext::TestSize.Lev
         std::string backupInfo = "backup info";
         auto ret = Init(IServiceReverse::Scenario::BACKUP);
         EXPECT_EQ(ret, BError(BError::Codes::OK));
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->GetBackupInfo(bundleName, backupInfo);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -903,6 +937,7 @@ HWTEST_F(ServiceTest, SUB_Service_UpdateTimer_0100, testing::ext::TestSize.Level
         std::string bundleName = "com.example.app2backup";
         bool result = true;
         uint32_t timeOut = 30000;
+        EXPECT_NE(servicePtr_, nullptr);
         servicePtr_->UpdateTimer(bundleName, timeOut, result);
     } catch (...) {
         EXPECT_TRUE(false);
diff --git a/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp
index 2b2478b575e940541e4c7082550d60bdaf333e75..76c7acfe2714fa638263c61dd019155dff73c2c7 100644
--- a/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp
@@ -79,6 +79,8 @@ HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_OnAbilityConnectDone_0100
     try {
         int resultCode = 0;
         AppExecFwk::ElementName element;
+        EXPECT_NE(backupCon_, nullptr);
+        EXPECT_NE(castMock, nullptr);
         backupCon_->OnAbilityConnectDone(element, nullptr, resultCode);
         EXPECT_TRUE(true);
 
@@ -111,6 +113,7 @@ HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_OnAbilityDisconnectDone_0
         element.SetBundleName(bundleName);
         int resultCode = 1;
 
+        EXPECT_NE(backupCon_, nullptr);
         backupCon_->isConnectedDone_ = false;
         backupCon_->OnAbilityDisconnectDone(element, resultCode);
         bool ret = backupCon_->IsExtAbilityConnected();
@@ -139,6 +142,7 @@ HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_OnAbilityDisconnectDone_0
 HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_GetBackupExtProxy_0100, testing::ext::TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "SvcBackupConnectionTest-begin SUB_BackupConnection_GetBackupExtProxy_0100";
+    EXPECT_NE(backupCon_, nullptr);
     auto proxy = backupCon_->GetBackupExtProxy();
     EXPECT_EQ(proxy, nullptr);
     GTEST_LOG_(INFO) << "SvcBackupConnectionTest-end SUB_BackupConnection_GetBackupExtProxy_0100";
diff --git a/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp
index d0016750a1c8768cf10e185803cb6884312535f8..f9ffbf068a64391e82bb3c0a25c7b6e2a509e3e7 100644
--- a/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp
@@ -72,6 +72,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetFileHandle_0100, test
         int32_t errCode = 0;
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+        EXPECT_NE(proxy_, nullptr);
         UniqueFd fd = proxy_->GetFileHandle(fileName, errCode);
         EXPECT_LT(fd, BError(BError::Codes::OK));
 
@@ -117,6 +118,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleClear_0100, testin
     try {
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->HandleClear();
         EXPECT_EQ(EPERM, ret);
 
@@ -147,6 +149,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleBackup_0100, testi
     try {
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->HandleBackup();
         EXPECT_EQ(EPERM, ret);
 
@@ -178,6 +181,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_PublishFile_0100, testin
         string fileName = "1.tar";
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->PublishFile(fileName);
         EXPECT_EQ(EPERM, ret);
 
@@ -215,6 +219,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleRestore_0100, test
     try {
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->HandleRestore();
         EXPECT_EQ(EPERM, ret);
 
@@ -246,6 +251,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetBackupInfo_0100, test
         string result = "result_report";
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->GetBackupInfo(result);
         EXPECT_EQ(EPERM, ret);
 
@@ -297,6 +303,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetIncrementalFileHandle
         string fileName = "1.tar";
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->GetIncrementalFileHandle(fileName);
         EXPECT_EQ(ret, ErrCode(EPERM));
 
@@ -335,6 +342,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_PublishIncrementalFile_0
         string fileName = "1.tar";
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->PublishIncrementalFile(fileName);
         EXPECT_EQ(ret, ErrCode(EPERM));
 
@@ -373,6 +381,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleIncrementalBackup_
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
+        EXPECT_NE(proxy_, nullptr);
         ErrCode ret = proxy_->HandleIncrementalBackup(UniqueFd(-1), UniqueFd(-1));
         EXPECT_EQ(ret, ErrCode(EPERM));
 
@@ -405,6 +414,7 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetIncrementalBackupFile
     try {
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
+        EXPECT_NE(proxy_, nullptr);
         auto [incrementalFd, manifestFd] = proxy_->GetIncrementalBackupFileHandle();
         EXPECT_EQ(incrementalFd, -1);
         EXPECT_EQ(manifestFd, -1);
diff --git a/tests/unittests/backup_sa/module_ipc/svc_restore_deps_manager_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_restore_deps_manager_test.cpp
index 4e37b337d990c93ec2ec5f066365b80d509fab55..133fcb9d3e59a0c85b09e232fdc45e1c2d8e5f33 100644
--- a/tests/unittests/backup_sa/module_ipc/svc_restore_deps_manager_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/svc_restore_deps_manager_test.cpp
@@ -363,6 +363,7 @@ HWTEST_F(SvcRestoreDepsManagerTest,
     bool ret = (it != SvcRestoreDepsManager::GetInstance().toRestoreBundleMap_.end());
     EXPECT_TRUE(ret);
     if (ret) {
+        EXPECT_NE(it, nullptr);
         EXPECT_EQ(it->second.fileNames_.size(), 2);
     }
     ClearCache();
diff --git a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp
index 660186171d985fbc38d1dcacf3551de038479e84..5ca811f5435cc9257d176435082a3b67e6203f83 100644
--- a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp
@@ -72,6 +72,7 @@ void SvcSessionManagerTest::Init(IServiceReverse::Scenario scenario)
     vector<string> bundleNames;
     map<string, BackupExtInfo> backupExtNameMap;
     bundleNames.emplace_back(BUNDLE_NAME);
+    EXPECT_NE(sessionManagerPtr_, nullptr);
     sessionManagerPtr_->Active(
         {.clientToken = CLIENT_TOKEN_ID, .scenario = scenario, .backupExtNameMap = {}, .clientProxy = remote_});
     sessionManagerPtr_->IsOnAllBundlesFinished();
@@ -94,6 +95,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_VerifyCallerAndScenario_01
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_VerifyCallerAndScenario_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
             sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, IServiceReverse::Scenario::RESTORE);
             EXPECT_TRUE(false);
@@ -136,6 +138,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Active_0100, testing::ext:
     try {
         SvcSessionManager::Impl newImpl;
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
             auto res = sessionManagerPtr_->Active(newImpl);
             EXPECT_EQ(res, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
@@ -192,6 +195,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Deactive_0100, testing::ex
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Deactive_0100";
     try {
         wptr<IRemoteObject> remoteInAction = nullptr;
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->impl_.clientToken = 0;
         sessionManagerPtr_->Deactive(remoteInAction, false);
         EXPECT_TRUE(true);
@@ -236,6 +240,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_VerifyBundleName_0100, tes
     try {
         string bundleName = BUNDLE_NAME;
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->VerifyBundleName(bundleName);
             EXPECT_TRUE(false);
@@ -277,6 +282,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceReverseProxy_010
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceReverseProxy_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientProxy = nullptr;
             sessionManagerPtr_->GetServiceReverseProxy();
             EXPECT_TRUE(false);
@@ -309,6 +315,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_getscenario_0100, testing:
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_getscenario_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetScenario();
             EXPECT_TRUE(false);
@@ -340,6 +347,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0100, te
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -396,6 +404,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0101, te
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0101";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->impl_.backupExtNameMap.clear();
         sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
@@ -445,6 +454,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleExtManageInfo_0100
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_OnBundleExtManageInfo_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1));
             EXPECT_TRUE(false);
@@ -494,6 +504,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupAbilityExt_0100,
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupAbilityExt_0100";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->reversePtr_ = nullptr;
         auto ret = sessionManagerPtr_->GetBackupAbilityExt(BUNDLE_NAME);
         ret->callDied_("");
@@ -525,6 +536,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupSAExt_0100, testi
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupSAExt_0100";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->reversePtr_ = nullptr;
         auto ret = sessionManagerPtr_->GetBackupSAExt(BUNDLE_NAME);
         ret->callDied_("");
@@ -563,6 +575,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_InitClient_0100, testing::
         SvcSessionManager::Impl newImpl;
         try {
             newImpl.clientProxy = nullptr;
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->InitClient(newImpl);
             EXPECT_TRUE(false);
         } catch (BError &err) {
@@ -593,6 +606,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0100
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, FILE_NAME);
             EXPECT_TRUE(false);
@@ -627,6 +641,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtConnection_0100, tes
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtConnection_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetExtConnection(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -680,6 +695,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSAExtConnection_0100, t
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetSAExtConnection_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -734,6 +750,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_DumpInfo_0100, testing::ex
         TestManager tm("SvcSessionManagerTest_GetFd_0100");
         string fileUri = tm.GetRootDirCurTest().append(FILE_NAME);
         UniqueFd fd(open(fileUri.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->DumpInfo(fd, {});
     } catch (...) {
         EXPECT_TRUE(false);
@@ -756,6 +773,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSchedBundleName_0100, t
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetSchedBundleName_0100";
     try {
         string bundleName;
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         bool condition = sessionManagerPtr_->GetSchedBundleName(bundleName);
         EXPECT_EQ(bundleName, BUNDLE_NAME);
         EXPECT_TRUE(condition);
@@ -789,6 +807,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0100
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0100";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         auto action = sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME);
         EXPECT_EQ(action, BConstants::ServiceSchedAction::WAIT);
 
@@ -817,6 +836,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0102
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0102";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         auto action = sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME);
         EXPECT_NE(action, BConstants::ServiceSchedAction::WAIT);
 
@@ -848,6 +868,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0103
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0103";
     try {
         string bundleName = "";
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         auto action = sessionManagerPtr_->GetServiceSchedAction(bundleName);
         EXPECT_EQ(action, BConstants::ServiceSchedAction::WAIT);
 
@@ -892,6 +913,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0100, tes
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtName_0100";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->SetBackupExtName(BUNDLE_NAME, BUNDLE_NAME);
         string extName = sessionManagerPtr_->GetBackupExtName(BUNDLE_NAME);
         EXPECT_EQ(extName, BUNDLE_NAME);
@@ -917,6 +939,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0101, tes
     try {
         string bundleName = "";
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetBackupExtName(bundleName, bundleName);
             EXPECT_TRUE(false);
@@ -958,6 +981,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBackupExtInfo_0100, tes
         string bundleName = BUNDLE_NAME;
         string extInfo = "test";
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo);
             EXPECT_TRUE(false);
@@ -993,6 +1017,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtInfo_0100, tes
         string bundleName = BUNDLE_NAME;
         string extInfo = "test";
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetBackupExtInfo(bundleName);
             EXPECT_TRUE(false);
@@ -1029,6 +1054,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_AppendBundles_0100, testin
     try {
         vector<BundleName> bundleNames;
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->AppendBundles(bundleNames);
             EXPECT_TRUE(false);
@@ -1070,6 +1096,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_NeedToUnloadService_0100,
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_NeedToUnloadService_0100";
     try {
 
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_READDY;
         auto ret = sessionManagerPtr_->NeedToUnloadService();
         EXPECT_FALSE(ret);
@@ -1107,6 +1134,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_removeextinfo_0100, testin
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_removeextinfo_0100";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->impl_.backupExtNameMap.clear();
         sessionManagerPtr_->RemoveExtInfo(BUNDLE_NAME);
         EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 0);
@@ -1144,6 +1172,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleFileReady_0200, te
 {
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_OnBundleFileReady_0200";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->Deactive(nullptr, true);
         Init(IServiceReverse::Scenario::BACKUP);
         auto ret = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON);
@@ -1173,6 +1202,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetSessionUserId_0100, tes
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_backup_sa_session_SetSessionUserId_0100";
     try {
         int32_t userId = 1;
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->SetSessionUserId(userId);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -1194,6 +1224,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSessionUserId_0100, tes
 {
     GTEST_LOG_(INFO) << "ServiceTest-begin SUB_backup_sa_session_GetSessionUserId_0100";
     try {
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->GetSessionUserId();
     } catch (...) {
         EXPECT_TRUE(false);
@@ -1216,6 +1247,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleRestoreType_0100,
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleRestoreType_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY);
             EXPECT_TRUE(false);
@@ -1249,6 +1281,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleRestoreType_0100,
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleRestoreType_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -1282,6 +1315,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionCode_0100,
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionCode_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0);
             EXPECT_TRUE(false);
@@ -1315,6 +1349,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionCode_0100,
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionCode_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -1348,6 +1383,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionName_0100,
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionName_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "1.0.0");
             EXPECT_TRUE(false);
@@ -1381,6 +1417,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionName_0100,
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionName_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -1414,6 +1451,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Start_0100, testing::ext::
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Start_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->Start();
             EXPECT_TRUE(false);
@@ -1445,6 +1483,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Finish_0100, testing::ext:
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Finish_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->Finish();
             EXPECT_TRUE(false);
@@ -1476,6 +1515,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnAllBundlesFinished_010
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnAllBundlesFinished_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->IsOnAllBundlesFinished();
             EXPECT_TRUE(false);
@@ -1513,6 +1553,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnOnStartSched_0100, tes
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnOnStartSched_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->IsOnOnStartSched();
             EXPECT_TRUE(false);
@@ -1556,6 +1597,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleDataSize_0100, te
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleDataSize_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetBundleDataSize(BUNDLE_NAME, 0);
             EXPECT_TRUE(false);
@@ -1590,6 +1632,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_BundleExtTimerStart_0100,
     try {
         auto callback = []() -> void {};
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->BundleExtTimerStart(BUNDLE_NAME, callback);
             EXPECT_TRUE(false);
@@ -1633,6 +1676,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_UpdateTimer_0100, testing:
     try {
         auto callback = []() -> void {};
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, 30, callback);
             EXPECT_TRUE(false);
@@ -1675,6 +1719,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_BundleExtTimerStop_0100, t
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_BundleExtTimerStop_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->BundleExtTimerStop(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -1720,6 +1765,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_ClearSessionData_0100, tes
         info.timerStatus = true;
         info.schedAction = BConstants::ServiceSchedAction::RUNNING;
         info.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr));
+        EXPECT_NE(sessionManagerPtr_, nullptr);
         sessionManagerPtr_->impl_.backupExtNameMap.clear();
         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
         sessionManagerPtr_->ClearSessionData();
@@ -1752,6 +1798,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIsIncrementalBackup_010
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIsIncrementalBackup_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetIsIncrementalBackup();
             EXPECT_TRUE(false);
@@ -1784,6 +1831,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetIncrementalData_0100, t
     try {
         BIncrementalData incrementalData;
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->SetIncrementalData(incrementalData);
             EXPECT_TRUE(false);
@@ -1818,6 +1866,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIncrementalManifestFd_0
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIncrementalManifestFd_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME);
             EXPECT_TRUE(false);
@@ -1851,6 +1900,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetLastIncrementalTime_010
     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetLastIncrementalTime_0100";
     try {
         try {
+            EXPECT_NE(sessionManagerPtr_, nullptr);
             sessionManagerPtr_->impl_.clientToken = 0;
             sessionManagerPtr_->GetLastIncrementalTime(BUNDLE_NAME);
             EXPECT_TRUE(false);
diff --git a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
index f9722e766331d5be133bbe70277907f7fff3bca7..26b2f68e3f422147b5ddc57599a9456436fb18aa 100644
--- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
+++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
@@ -72,6 +72,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0100, testing::e
     try {
         ServiceProxy::serviceProxy_ = nullptr;
         BIncrementalBackupSession::Callbacks callbacks;
+        EXPECT_NE(backupSession, nullptr);
         auto err = backupSession->Init(callbacks);
         EXPECT_EQ(err, nullptr);
 
@@ -103,6 +104,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0200, testing::e
     GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_0200";
     try {
         ServiceProxy::serviceProxy_ = nullptr;
+        EXPECT_NE(backupSession, nullptr);
         backupSession->RegisterBackupServiceDied(nullptr);
 
         ServiceProxy::serviceProxy_ = proxy;
@@ -132,6 +134,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0300, testing::e
     try {
         ServiceProxy::serviceProxy_ = nullptr;
         vector<BIncrementalData> bundlesToBackup;
+        EXPECT_NE(backupSession, nullptr);
         auto err = backupSession->AppendBundles(bundlesToBackup);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -160,6 +163,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0400, testing::e
     GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_0400";
     try {
         ServiceProxy::serviceProxy_ = nullptr;
+        EXPECT_NE(backupSession, nullptr);
         auto err = backupSession->Release();
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -189,6 +193,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0500, testing::e
     try {
         ServiceProxy::serviceProxy_ = nullptr;
         BIncrementalRestoreSession::Callbacks callbacks;
+        EXPECT_NE(restoreSession, nullptr);
         auto err = restoreSession->Init(callbacks);
         EXPECT_EQ(err, nullptr);
 
@@ -220,6 +225,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0600, testing::e
     GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_0600";
     try {
         ServiceProxy::serviceProxy_ = nullptr;
+        EXPECT_NE(restoreSession, nullptr);
         restoreSession->RegisterBackupServiceDied(nullptr);
 
         ServiceProxy::serviceProxy_ = proxy;
@@ -250,6 +256,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0700, testing::e
         ServiceProxy::serviceProxy_ = nullptr;
         UniqueFd remoteCap1;
         vector<BundleName> bundlesToRestore;
+        EXPECT_NE(restoreSession, nullptr);
         auto err = restoreSession->AppendBundles(move(remoteCap1), bundlesToRestore);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -279,6 +286,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0800, testing::e
     GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_0800";
     try {
         ServiceProxy::serviceProxy_ = nullptr;
+        EXPECT_NE(restoreSession, nullptr);
         auto err = restoreSession->Release();
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -308,6 +316,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_0900, testing::e
     try {
         ServiceProxy::serviceProxy_ = nullptr;
         BFileInfo fileInfo;
+        EXPECT_NE(restoreSession, nullptr);
         auto err = restoreSession->PublishFile(fileInfo);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -339,6 +348,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1000, testing::e
         ServiceProxy::serviceProxy_ = nullptr;
         string bundleName;
         string fileName;
+        EXPECT_NE(restoreSession, nullptr);
         auto err = restoreSession->GetFileHandle(bundleName, fileName);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -370,6 +380,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1100, testing::e
         UniqueFd remoteCap;
         vector<BundleName> bundlesToRestore;
         vector<std::string> detailInfos;
+        EXPECT_NE(restoreSession, nullptr);
         auto err = restoreSession->AppendBundles(move(remoteCap), bundlesToRestore, detailInfos);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -399,6 +410,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1200, testing::e
     try {
         ServiceProxy::serviceProxy_ = nullptr;
         BIncrementalSessionRestoreAsync::Callbacks callbacks;
+        EXPECT_NE(restoreAsyncSession, nullptr);
         auto err = restoreAsyncSession->Init(callbacks);
         EXPECT_EQ(err, nullptr);
 
@@ -430,6 +442,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1300, testing::e
     GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_1300";
     try {
         ServiceProxy::serviceProxy_ = nullptr;
+        EXPECT_NE(restoreAsyncSession, nullptr);
         restoreAsyncSession->RegisterBackupServiceDied(nullptr);
 
         ServiceProxy::serviceProxy_ = proxy;
@@ -460,6 +473,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1400, testing::e
         ServiceProxy::serviceProxy_ = nullptr;
         UniqueFd remoteCap1;
         vector<BundleName> bundlesToRestore;
+        EXPECT_NE(restoreAsyncSession, nullptr);
         auto err = restoreAsyncSession->AppendBundles(move(remoteCap1), bundlesToRestore);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -490,6 +504,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1500, testing::e
     try {
         ServiceProxy::serviceProxy_ = nullptr;
         BFileInfo fileInfo;
+        EXPECT_NE(restoreAsyncSession, nullptr);
         auto err = restoreAsyncSession->PublishFile(fileInfo);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -521,6 +536,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1600, testing::e
         ServiceProxy::serviceProxy_ = nullptr;
         string bundleName;
         string fileName;
+        EXPECT_NE(restoreAsyncSession, nullptr);
         auto err = restoreAsyncSession->GetFileHandle(bundleName, fileName);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -552,6 +568,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1700, testing::e
         UniqueFd remoteCap;
         vector<BundleName> bundlesToRestore;
         vector<std::string> detailInfos;
+        EXPECT_NE(restoreAsyncSession, nullptr);
         auto err = restoreAsyncSession->AppendBundles(move(remoteCap), bundlesToRestore, detailInfos);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -580,6 +597,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1800, testing::e
     GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_1800";
     try {
         ServiceProxy::serviceProxy_ = nullptr;
+        EXPECT_NE(restoreAsyncSession, nullptr);
         auto err = restoreAsyncSession->Release();
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
@@ -610,6 +628,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_1900, testing::e
         ServiceProxy::serviceProxy_ = nullptr;
         vector<BIncrementalData> bundlesToBackup;
         vector<std::string> infos;
+        EXPECT_NE(backupSession, nullptr);
         auto err = backupSession->AppendBundles(bundlesToBackup, infos);
         EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
 
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp
index e9c7c9cfd0337699748a3c7d039a66efcb9367b6..7bdf8e24ea0cd13bef3c65063ca73073d0f4e651 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp
@@ -42,6 +42,7 @@ static void PerformBackupOperation(map<string, vector<string>> &mapArgToVal)
     auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
     auto &&opeartions = ToolsOp::GetAllOperations();
     auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+    EXPECT_NE(matchedOp, nullptr);
     if (matchedOp != opeartions.end()) {
         auto ret = matchedOp->Execute(mapArgToVal);
         EXPECT_EQ(ret, 0);
@@ -120,6 +121,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp
index 1d3dc50783580faa8260e5316f0c751029622812..239cdf111517eab56042935fdee8fba12627ba30 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp
@@ -53,6 +53,7 @@ HWTEST_F(ToolsOpCheckSaTest, SUB_backup_tools_op_check_sa_0100, testing::ext::Te
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
@@ -94,6 +95,7 @@ HWTEST_F(ToolsOpCheckSaTest, SUB_backup_tools_op_check_sa_0200, testing::ext::Te
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp
index f3d9e6902095596ea865c69ad8d8ba48c8c4872a..e888520e6709039b5d9002d5a5f914bb27c03b88 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp
@@ -58,6 +58,7 @@ HWTEST_F(ToolsOpHelpTest, SUB_backup_tools_op_help_0101, testing::ext::TestSize.
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         if (matchedOp != opeartions.end()) {
             matchedOp->Execute(mapArgToVal);
         }
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_incremental_backup_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_incremental_backup_test.cpp
index a4b7542221e8ebbcbdb4634a1cf2cbfcf28be507..edd10ded0c009932bea074427b1d4cc120fb43e8 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_incremental_backup_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_incremental_backup_test.cpp
@@ -65,6 +65,7 @@ HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_01
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         if (matchedOp != opeartions.end()) {
             auto ret = matchedOp->Execute(mapArgToVal);
             EXPECT_EQ(ret, 0);
@@ -102,6 +103,7 @@ HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_02
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
@@ -168,6 +170,7 @@ HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_03
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         if (matchedOp != opeartions.end()) {
             auto ret = matchedOp->Execute(mapArgToVal);
             EXPECT_EQ(ret, 0);
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_incremental_restore_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_incremental_restore_test.cpp
index a5f8038a86e12ef98b2aca2acec51a54f144b8e0..e059ad2d97e4a4e26aefe91bc03de3fa3230bb15 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_incremental_restore_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_incremental_restore_test.cpp
@@ -82,6 +82,7 @@ HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         if (matchedOp != opeartions.end()) {
             auto ret = matchedOp->Execute(mapArgToVal);
             EXPECT_EQ(ret, 0);
@@ -119,6 +120,7 @@ HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
@@ -184,6 +186,7 @@ HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp
index 109d465f18d8c9880b952d5b67455dfbea2e9586..8f98ecb4eed2a972d67c56662c845321c8e53c5b 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp
@@ -91,6 +91,7 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0100, testin
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         if (matchedOp != opeartions.end()) {
             auto ret = matchedOp->Execute(mapArgToVal);
             EXPECT_EQ(ret, 0);
@@ -106,7 +107,6 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0100, testin
             auto ret = matchedOp->Execute(mapArgToVal);
             EXPECT_EQ(ret, 0);
         }
-
     } catch (...) {
         EXPECT_TRUE(false);
         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
@@ -142,6 +142,7 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0200, testin
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp
index 3d7220db85a358fa0c4f93d12d617b5967018527..ba91c80eca3f4efc6ff94c85c294ba31aa8aac3c 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp
@@ -88,6 +88,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0100, testing::ext::Tes
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         if (matchedOp != opeartions.end()) {
             auto ret = matchedOp->Execute(mapArgToVal);
             EXPECT_EQ(ret, 0);
@@ -123,6 +124,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0200, testing::ext::Tes
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOperation = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOperation, nullptr);
         int ret = 0;
         if (matchedOperation != opeartions.end()) {
             ret = matchedOperation->Execute(mapArgToVal);
@@ -176,6 +178,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0300, testing::ext::Tes
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         int ret = 0;
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
@@ -235,6 +238,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0400, testing::ext::Tes
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOpIterator = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOpIterator, nullptr);
         int ret = 0;
         if (matchedOpIterator != opeartions.end()) {
             ret = matchedOpIterator->Execute(mapArgToVal);
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp
index 836802a2ca0513a41a2f075f87a7dbf08efa9f10..ebcc2de5294f8b3bc205312a17028195e64b9943 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp
@@ -59,6 +59,7 @@ HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0100, testing::ext::TestSize.Level1)
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOpIterator = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOpIterator, nullptr);
         if (matchedOpIterator != opeartions.end()) {
             matchedOpIterator->Execute(mapArgToVal);
         }
@@ -142,6 +143,7 @@ HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0400, testing::ext::TestSize.Level1)
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
         auto &&opeartions = ToolsOp::GetAllOperations();
         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        EXPECT_NE(matchedOp, nullptr);
         if (matchedOp != opeartions.end()) {
             matchedOp->Execute(mapArgToVal);
         }
diff --git a/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp b/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp
index a09c55ebcb4078fde2d0f056290d2126acc82c6c..3087588c216f80474782d74d67e29480f1dd4da6 100644
--- a/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp
+++ b/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp
@@ -74,6 +74,8 @@ bool IsEqual(const map<string, tuple<string, struct stat, bool>> &lf,
 
     auto itemLF = lf.begin();
     auto itemRH = rh.begin();
+    EXPECT_NE(itemLF, nullptr);
+    EXPECT_NE(itemRH, nullptr);
     for (; itemLF != lf.end(); ++itemLF, ++itemRH) {
         if (itemLF->first != itemRH->first) {
             return false;
diff --git a/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp b/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp
index f86a5147237fc4e9c80c7b687b04740c65c586c7..b1983cc67ea01aa563c7248d5760d235ffabc42e 100644
--- a/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp
+++ b/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp
@@ -54,6 +54,7 @@ HWTEST_F(BTarballFactoryTest, b_tarball_factory_0100, testing::ext::TestSize.Lev
         SaveStringToFile(tarballPath, "data/storage/el2/database/");
         // 调用create获取打包解包能力
         auto tarballTar = BTarballFactory::Create(implType, tarballPath);
+        EXPECT_NE(tarballTar, nullptr);
         GTEST_LOG_(INFO) << "BTarballFactoryTest-tar";
         (tarballTar->tar)("/", {}, {"/data/storage/el2/database/", {}});
         GTEST_LOG_(INFO) << "BTarballFactoryTest-untar";
@@ -86,6 +87,7 @@ HWTEST_F(BTarballFactoryTest, b_tarball_factory_0200, testing::ext::TestSize.Lev
         SaveStringToFile(tarballPath, "data/storage/el2/database/");
         // 调用create获取打包解包能力
         auto tarballTar = BTarballFactory::Create(type, tarballPath);
+        EXPECT_NE(tarballTar, nullptr);
         GTEST_LOG_(INFO) << "BTarballFactoryTest-tar";
         (tarballTar->tar)("/", {}, {"/data/storage/el2/database/", {}});
         GTEST_LOG_(INFO) << "BTarballFactoryTest-untar";
@@ -118,6 +120,7 @@ HWTEST_F(BTarballFactoryTest, b_tarball_factory_0300, testing::ext::TestSize.Lev
         SaveStringToFile(path, "data/storage/el2/database/");
         // 调用create获取打包解包能力
         auto tarballTar = BTarballFactory::Create(implType, path);
+        EXPECT_NE(tarballTar, nullptr);
         GTEST_LOG_(INFO) << "BTarballFactoryTest-tar";
         (tarballTar->tar)("/", {}, {"/data/storage/el2/database/", {}});
         GTEST_LOG_(INFO) << "BTarballFactoryTest-untar";
@@ -150,6 +153,7 @@ HWTEST_F(BTarballFactoryTest, b_tarball_factory_0400, testing::ext::TestSize.Lev
         SaveStringToFile(tarballPath, "data/storage/el2/database/");
         // 调用create获取打包解包能力
         auto tarballTar = BTarballFactory::Create(implType, tarballPath);
+        EXPECT_NE(tarballTar, nullptr);
         GTEST_LOG_(INFO) << "BTarballFactoryTest-tar";
         (tarballTar->tar)("/", {}, {"/data/storage/el2/database/", {}});
         GTEST_LOG_(INFO) << "BTarballFactoryTest-untar";