diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
index 3525f00070777ad70c5337c268d67d2f41ba90e4..008b7addaee430244d63c6691100b7120fdd5bc2 100644
--- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
@@ -312,13 +312,13 @@ int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args)
     ret = micClient->Release();
     CHECK_AND_LOG(ret != DH_SUCCESS, "Release mic client failed, ret: %{public}d.", ret);
     micClientMap_.erase(dhId);
-    if (isPageStatus_.load()) {
+    if (isPageStatus_.load() && ipcSinkCallback_ != nullptr) {
         bool isSensitive = false;
         bool isSameAccount = false;
         ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, SUBTYPE, devId_,
             isSensitive, isSameAccount);
+        isPageStatus_.store(false);
     }
-    isPageStatus_.store(false);
     DHLOGI("Close mic device task excute success.");
     return DH_SUCCESS;
 }
@@ -479,9 +479,11 @@ void DAudioSinkDev::PullUpPage()
 {
     bool isSensitive = false;
     bool isSameAccount = false;
-    ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_PULL_UP_PAGE, SUBTYPE, devId_,
-        isSensitive, isSameAccount);
-    isPageStatus_.store(true);
+    if (ipcSinkCallback_ != nullptr) {
+        ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_PULL_UP_PAGE, SUBTYPE, devId_,
+            isSensitive, isSameAccount);
+        isPageStatus_.store(true);
+    }
 }
 
 void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string dhId, const int32_t result)
@@ -613,6 +615,7 @@ DAudioSinkDev::SinkEventHandler::~SinkEventHandler() {}
 
 void DAudioSinkDev::SinkEventHandler::ProcessEventInner(const AppExecFwk::InnerEvent::Pointer &event)
 {
+    CHECK_NULL_VOID(event);
     switch (event->GetInnerEventId()) {
         case OPEN_MIC:
             NotifyOpenMic(event);
@@ -654,6 +657,7 @@ void DAudioSinkDev::SinkEventHandler::ProcessEventInner(const AppExecFwk::InnerE
 
 void DAudioSinkDev::SinkEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
 {
+    CHECK_NULL_VOID(event);
     DHLOGI("Event Id=%{public}d", event->GetInnerEventId());
     switch (event->GetInnerEventId()) {
         case CTRL_OPENED:
diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
index da23c9da3e04aa0e78df5f17778c83aecef9b90e..f38d2b70a80b83d67b74063eab8063cde1b8d087 100644
--- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
@@ -404,6 +404,7 @@ int32_t DAudioSinkManager::PauseDistributedHardware(const std::string &networkId
     std::lock_guard<std::mutex> lock(devMapMutex_);
     if (audioDevMap_.find(networkId) != audioDevMap_.end()) {
         DHLOGI("Audio sink dev in map. devId: %{public}s.", GetAnonyString(networkId).c_str());
+        CHECK_NULL_RETURN(audioDevMap_[networkId], ERR_DH_AUDIO_NULLPTR);
         audioDevMap_[networkId]->PauseDistributedHardware(networkId);
     }
     return DH_SUCCESS;
@@ -414,6 +415,7 @@ int32_t DAudioSinkManager::ResumeDistributedHardware(const std::string &networkI
     std::lock_guard<std::mutex> lock(devMapMutex_);
     if (audioDevMap_.find(networkId) != audioDevMap_.end()) {
         DHLOGI("Audio sink dev in map. devId: %{public}s.", GetAnonyString(networkId).c_str());
+        CHECK_NULL_RETURN(audioDevMap_[networkId], ERR_DH_AUDIO_NULLPTR);
         audioDevMap_[networkId]->ResumeDistributedHardware(networkId);
     }
     return DH_SUCCESS;
@@ -424,6 +426,7 @@ int32_t DAudioSinkManager::StopDistributedHardware(const std::string &networkId)
     std::lock_guard<std::mutex> lock(devMapMutex_);
     if (audioDevMap_.find(networkId) != audioDevMap_.end()) {
         DHLOGI("Audio sink dev in map. devId: %{public}s.", GetAnonyString(networkId).c_str());
+        CHECK_NULL_RETURN(audioDevMap_[networkId], ERR_DH_AUDIO_NULLPTR);
         audioDevMap_[networkId]->StopDistributedHardware(networkId);
     }
     return DH_SUCCESS;
@@ -508,6 +511,7 @@ std::string DAudioSinkManager::GetUdidByNetworkId(const std::string &networkId)
 int32_t DAudioSinkManager::VerifySecurityLevel(const std::string &devId)
 {
     std::string subType = "mic";
+    CHECK_NULL_RETURN(ipcSinkCallback_, ERR_DH_AUDIO_FAILED);
     int32_t ret = ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_QUERY_RESOURCE, subType, devId,
         isSensitive_, isSameAccount_);
     if (ret != DH_SUCCESS) {
diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp
index 300c50c92d274c975cb85d1bb62e43367028cd5f..efd6bc816e8c40aed035a9fa4a10fcb97608a0df 100644
--- a/services/audiomanager/managersource/src/daudio_source_dev.cpp
+++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp
@@ -904,6 +904,7 @@ int32_t DAudioSourceDev::ConvertString2Int(std::string val)
 
 int32_t DAudioSourceDev::OpenDSpeakerInner(std::shared_ptr<DAudioIoDev> &speaker, const int32_t dhId)
 {
+    CHECK_NULL_RETURN(speaker, ERR_DH_AUDIO_NULLPTR);
     int32_t ret = speaker->SetUp();
     if (ret != DH_SUCCESS) {
         DHLOGE("Speaker setup failed, error code %{public}d.", ret);
@@ -1316,6 +1317,7 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const cJSON *P
         cJSON_Delete(jParam);
         return ERR_DH_AUDIO_NULLPTR;
     }
+    CHECK_NULL_RETURN(ioDev, ERR_DH_AUDIO_NULLPTR);
     ioDev->SendMessage(static_cast<uint32_t>(type), std::string(content), devId_);
     if (type == CLOSE_SPEAKER || type == CLOSE_MIC) {
         // Close spk || Close mic  do not need to wait RPC
@@ -1337,6 +1339,7 @@ int32_t DAudioSourceDev::NotifyHDF(const AudioEventType type, const std::string
         return ERR_DH_AUDIO_NULLPTR;
     }
     auto ioDev = deviceMap_[dhId];
+    CHECK_NULL_RETURN(ioDev, ERR_DH_AUDIO_NULLPTR);
     AudioEvent event(type, result);
     switch (type) {
         case NOTIFY_OPEN_SPEAKER_RESULT:
@@ -1404,6 +1407,7 @@ DAudioSourceDev::SourceEventHandler::~SourceEventHandler() {}
 
 void DAudioSourceDev::SourceEventHandler::ProcessEventInner(const AppExecFwk::InnerEvent::Pointer &event)
 {
+    CHECK_NULL_VOID(event);
     switch (event->GetInnerEventId()) {
         case EVENT_VOLUME_SET:
             SetVolumeCallback(event);
@@ -1439,6 +1443,7 @@ void DAudioSourceDev::SourceEventHandler::ProcessEventInner(const AppExecFwk::In
 
 void DAudioSourceDev::SourceEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
 {
+    CHECK_NULL_VOID(event);
     DHLOGI("Event Id=%{public}d", event->GetInnerEventId());
     switch (event->GetInnerEventId()) {
         case EVENT_DAUDIO_ENABLE:
diff --git a/services/audiomanager/managersource/src/daudio_source_manager.cpp b/services/audiomanager/managersource/src/daudio_source_manager.cpp
index d0848a3b16f91e6fccf1791d19af047eefce1c85..4723774e4fcdcd8302c589d22b3b1980d93d3e4e 100644
--- a/services/audiomanager/managersource/src/daudio_source_manager.cpp
+++ b/services/audiomanager/managersource/src/daudio_source_manager.cpp
@@ -591,6 +591,7 @@ DAudioSourceManager::SourceManagerHandler::~SourceManagerHandler() {}
 
 void DAudioSourceManager::SourceManagerHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
 {
+    CHECK_NULL_VOID(event);
     DHLOGI("Event Id=%{public}d.", event->GetInnerEventId());
     switch (event->GetInnerEventId()) {
         case EVENT_MANAGER_ENABLE_DAUDIO:
diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp
index b0a17feaf04fb9cd779a27cdba1b26c51a404870..93ec08b54d4fbb08232160076916d1054352fc8a 100644
--- a/services/audiomanager/managersource/src/dmic_dev.cpp
+++ b/services/audiomanager/managersource/src/dmic_dev.cpp
@@ -380,7 +380,7 @@ int32_t DMicDev::ReadStreamData(const int32_t streamId, std::shared_ptr<AudioDat
         data = dataQueue_.front();
         dataQueue_.pop();
     }
-
+    CHECK_NULL_RETURN(data, ERR_DH_AUDIO_NULLPTR);
     DumpFileUtil::WriteDumpFile(dumpFileCommn_, static_cast<void *>(data->Data()), data->Size());
     int64_t endTime = GetNowTimeUs();
     if (IsOutDurationRange(startTime, endTime, lastReadStartTime_)) {
diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp
index 3f65db0f0a1f90b2d94f01d006940f6b2349c829..00a7e95608c1fecf8bfce4fa1ea8104453831b62 100644
--- a/services/audiomanager/managersource/src/dspeaker_dev.cpp
+++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp
@@ -300,6 +300,7 @@ int32_t DSpeakerDev::WriteStreamData(const int32_t streamId, std::shared_ptr<Aud
     DHLOGD("Write stream data, streamId:%{public}d", streamId);
     int64_t startTime = GetNowTimeUs();
     CHECK_NULL_RETURN(speakerTrans_, ERR_DH_AUDIO_NULLPTR);
+    CHECK_NULL_RETURN(data, ERR_DH_AUDIO_NULLPTR);
     DumpFileUtil::WriteDumpFile(dumpFileCommn_, static_cast<void *>(data->Data()), data->Size());
     int32_t ret = speakerTrans_->FeedAudioData(data);
     if (ret != DH_SUCCESS) {
diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
index 7047ff58d45f4f0b5db4dfc6a1fb6964edc86595..a66d183a9610097099b9dfd88d8093aa3cf636b0 100644
--- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
+++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
@@ -71,7 +71,7 @@ HWTEST_F(DAudioSinkDevTest, InitAVTransEngines_001, TestSize.Level1)
     std::shared_ptr<IAVEngineProvider> senderPtr = std::make_shared<IAVEngineProvider>();
     std::shared_ptr<IAVEngineProvider> receiverPtr = std::make_shared<IAVEngineProvider>();
     ChannelState type = ChannelState::UNKNOWN;
-
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->InitAVTransEngines(type, receiverPtr.get()));
     type = ChannelState::MIC_CONTROL_OPENED;
     EXPECT_EQ(DH_SUCCESS, sinkDev_->InitAVTransEngines(type, senderPtr.get()));
@@ -87,6 +87,7 @@ HWTEST_F(DAudioSinkDevTest, InitAVTransEngines_001, TestSize.Level1)
  */
 HWTEST_F(DAudioSinkDevTest, TaskPlayStatusChange_001, TestSize.Level1)
 {
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskPlayStatusChange(""));
 
     std::string devId = "devid";
@@ -105,6 +106,7 @@ HWTEST_F(DAudioSinkDevTest, TaskPlayStatusChange_001, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskDisableDevice_001, TestSize.Level1)
 {
     std::string spkName = "ohos.dhardware.daudio.dspeaker.ohos.dhardware.daudio.dmic";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskDisableDevice(spkName));
 }
 
@@ -117,6 +119,7 @@ HWTEST_F(DAudioSinkDevTest, TaskDisableDevice_001, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_001, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
     args.resize(DAUDIO_MAX_JSON_LEN + 1);
     EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sinkDev_->TaskOpenDSpeaker(args));
@@ -131,6 +134,7 @@ HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_001, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_002, TestSize.Level1)
 {
     std::string args = "args";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
 }
 
@@ -161,6 +165,7 @@ HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_003, TestSize.Level1)
     std::string args(jsonData);
     cJSON_free(jsonData);
     cJSON_Delete(jobject);
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
@@ -176,6 +181,7 @@ HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_003, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_001, TestSize.Level1)
 {
     std::string args = "{\"dhId\":\"1\"}";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
 }
 
@@ -190,6 +196,7 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1)
     std::string args = "{\"dhId\":\"1\"}";
     std::string devId = "devId";
     int32_t dhId = 1;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
@@ -205,6 +212,7 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, ParseDhidFromEvent_001, TestSize.Level1)
 {
     std::string args = "{\"devId\":\"1\"}";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(args));
     std::string dhIdArgs = "{\"dhId\": 1 }";
     EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(dhIdArgs));
@@ -219,6 +227,7 @@ HWTEST_F(DAudioSinkDevTest, ParseDhidFromEvent_001, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, ParseResultFromEvent_001, TestSize.Level1)
 {
     std::string args = "{\"result\":\"-40001\"}";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(-1, sinkDev_->ParseResultFromEvent(args));
     std::string dhIdArgs = "{\"result\": 1 }";
     EXPECT_NE(DH_SUCCESS, sinkDev_->ParseResultFromEvent(dhIdArgs));
@@ -249,6 +258,7 @@ HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1)
     std::string devId = "devId";
     int32_t dhId = 1;
     std::string args = "{\"dhId\":\"1\"}";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender(args));
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
@@ -266,6 +276,7 @@ HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_001, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
 }
 
@@ -277,6 +288,7 @@ HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_001, TestSize.Level1)
  */
 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_002, TestSize.Level1)
 {
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->isDevLevelStatus_ = true;
     std::string devId = "1";
     int32_t dhId = 1;
@@ -312,6 +324,7 @@ HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_003, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->isDevLevelStatus_ = true;
     EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sinkDev_->TaskOpenDMic(args));
     args = "{\"dhId\":\"1\"}";
@@ -329,6 +342,7 @@ HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_003, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_001, TestSize.Level1)
 {
     std::string args = "{\"dhId\":\"1\"}";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
 }
 
@@ -344,6 +358,7 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_002, TestSize.Level1)
     std::string devId;
     int32_t dhId = 1 << 27 | 1 << 0;
     auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
     std::string dhIdArgs = "{\"dhId\":1}";
@@ -361,6 +376,7 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_003, TestSize.Level1)
     std::string args = "{\"dhId\":\"-1\"}";
     std::string devId;
     int32_t dhId = 1;
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->isPageStatus_ = true;
     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskCloseDMic(args));
     args = "{\"dhId\":\"1\"}";
@@ -378,6 +394,7 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_003, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskSetParameter_001, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
     int32_t dhId = 1;
     std::string devId = "devId";
@@ -400,6 +417,7 @@ HWTEST_F(DAudioSinkDevTest, TaskSetParameter_002, TestSize.Level1)
     std::string devId;
     int32_t dhId = 1;
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
 }
@@ -413,6 +431,7 @@ HWTEST_F(DAudioSinkDevTest, TaskSetParameter_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskSetVolume_001, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
 }
 
@@ -427,6 +446,7 @@ HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1)
     std::string args = "{\"dhId\":\"1\"}";
     std::string devId;
     int32_t dhId = 1;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
@@ -444,6 +464,7 @@ HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskSetMute_001, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
 }
 
@@ -459,6 +480,7 @@ HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1)
     std::string devId = "devId";
     int32_t dhId = 1;
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
     std::string args1 = "dhId=1";
@@ -474,6 +496,7 @@ HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_001, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
 }
 
@@ -487,6 +510,7 @@ HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_002, TestSize.Level1)
 {
     std::string args;
     std::string devId = "devId";
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
 }
@@ -500,6 +524,7 @@ HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskFocusChange_001, TestSize.Level1)
 {
     std::string args;
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
 }
 
@@ -513,6 +538,7 @@ HWTEST_F(DAudioSinkDevTest, TaskFocusChange_002, TestSize.Level1)
 {
     std::string args;
     std::string devId = "devId";
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
 }
@@ -533,6 +559,7 @@ HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_001, TestSize.Level1)
     std::string dhIdS = "1";
     std::string dhIdM = "134217729";
     int32_t result = 0;
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->NotifySourceDev(AUDIO_START, dhId, result);
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhIdSpk, sinkDev_);
     sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
@@ -560,6 +587,7 @@ HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_002, TestSize.Level1)
     cJSON *j = cJSON_CreateObject();
     CHECK_NULL_VOID(j);
     AudioParam audioParam;
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args));
     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->from_json(j, audioParam));
@@ -578,6 +606,7 @@ HWTEST_F(DAudioSinkDevTest, SendAudioEventToRemote_002, TestSize.Level1)
     int32_t dhId = 1;
     AudioEvent event;
     event.content = "{\"dhId\":\"1\"}";
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
     auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
     sinkDev_->spkClientMap_.insert(std::make_pair(dhId, spkClient));
@@ -593,6 +622,7 @@ HWTEST_F(DAudioSinkDevTest, SendAudioEventToRemote_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, PauseDistributedHardware_001, TestSize.Level1)
 {
     std::string networkId = "networkId";
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->PullUpPage();
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->PauseDistributedHardware(networkId));
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->ResumeDistributedHardware(networkId));
@@ -607,6 +637,7 @@ HWTEST_F(DAudioSinkDevTest, PauseDistributedHardware_001, TestSize.Level1)
  */
 HWTEST_F(DAudioSinkDevTest, JudgeDeviceStatus_001, TestSize.Level1)
 {
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->JudgeDeviceStatus();
     sinkDev_->isSpkInUse_.store(true);
     sinkDev_->JudgeDeviceStatus();
@@ -631,7 +662,9 @@ HWTEST_F(DAudioSinkDevTest, SinkEventHandler_001, TestSize.Level1)
     AudioEvent audioEvent(eventType, eventContent);
     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
+    ASSERT_NE(sinkDev_->handler_, nullptr);
     sinkDev_->handler_->ProcessEvent(msgEvent);
     eventType = CTRL_OPENED;
     std::string content = "content";
@@ -664,9 +697,11 @@ HWTEST_F(DAudioSinkDevTest, SinkEventHandler_002, TestSize.Level1)
     AudioEvent audioEvent(eventType, eventContent);
     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
     sinkDev_->spkClientMap_[dhId] = nullptr;
     sinkDev_->micClientMap_[dhId] = nullptr;
+    ASSERT_NE(sinkDev_->handler_, nullptr);
     sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
     auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
     sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
@@ -700,6 +735,7 @@ HWTEST_F(DAudioSinkDevTest, SinkEventHandler_003, TestSize.Level1)
     AudioEvent audioEvent(eventType, devId);
     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
     sinkDev_->handler_->NotifyOpenSpeaker(msgEvent);
     sinkDev_->handler_->NotifyOpenMic(msgEvent);
@@ -721,7 +757,9 @@ HWTEST_F(DAudioSinkDevTest, SinkEventHandler_004, TestSize.Level1)
     int32_t eventType = OPEN_SPEAKER;
     std::shared_ptr<AudioEvent> nullForFail = nullptr;
     auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(eventType), nullForFail, 0);
+    ASSERT_NE(sinkDev_, nullptr);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
+    ASSERT_NE(sinkDev_->handler_, nullptr);
     sinkDev_->handler_->NotifyCtrlOpened(msgEvent);
     sinkDev_->handler_->NotifyCtrlClosed(msgEvent);
     sinkDev_->handler_->NotifyOpenSpeaker(msgEvent);
@@ -778,6 +816,7 @@ HWTEST_F(DAudioSinkDevTest, NotifyCtrlClosed_001, TestSize.Level1)
     std::string eventContent3 = "ohos.dhardware.daudio.dspeaker.ohos.dhardware.daudio.dmic";
     int32_t eventType = DISABLE_DEVICE;
     AudioEvent audioEvent(eventType, eventContent1);
+    ASSERT_NE(sinkDev_, nullptr);
     sinkDev_->NotifyEvent(audioEvent);
     audioEvent.content = eventContent2;
     sinkDev_->NotifyEvent(audioEvent);
@@ -791,6 +830,7 @@ HWTEST_F(DAudioSinkDevTest, NotifyCtrlClosed_001, TestSize.Level1)
     auto eventParam = std::make_shared<AudioEvent>(audioEvent);
     auto msg = AppExecFwk::InnerEvent::Get(static_cast<uint32_t>(audioEvent.type), eventParam, 0);
     EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev());
+    ASSERT_NE(sinkDev_->handler_, nullptr);
     sinkDev_->handler_->NotifyCtrlClosed(msg);
     audioEvent.content = "{\"dhId\":\"134217729\"}";
     eventParam = std::make_shared<AudioEvent>(audioEvent);
diff --git a/services/audioprocessor/test/unittest/common/directprocessor/audio_direct_processor_test.cpp b/services/audioprocessor/test/unittest/common/directprocessor/audio_direct_processor_test.cpp
index 4e0e99642955e32fb74315b465153307acbd372e..0140cd675e76b018845666a85cb4e190f1bd24f9 100644
--- a/services/audioprocessor/test/unittest/common/directprocessor/audio_direct_processor_test.cpp
+++ b/services/audioprocessor/test/unittest/common/directprocessor/audio_direct_processor_test.cpp
@@ -59,6 +59,7 @@ HWTEST_F(AudioDirectProcessorTest, ConfigureAudioProcessor_001, TestSize.Level1)
 {
     AudioCommonParam param;
     std::shared_ptr<IAudioProcessorCallback> procCallback = nullptr;
+    ASSERT_NE(processor_, nullptr);
     EXPECT_NE(DH_SUCCESS, processor_->ConfigureAudioProcessor(param, param, procCallback));
 }
 
@@ -70,6 +71,7 @@ HWTEST_F(AudioDirectProcessorTest, ConfigureAudioProcessor_001, TestSize.Level1)
  */
 HWTEST_F(AudioDirectProcessorTest, StartAudioProcessor_001, TestSize.Level1)
 {
+    ASSERT_NE(processor_, nullptr);
     EXPECT_EQ(DH_SUCCESS, processor_->StartAudioProcessor());
     EXPECT_EQ(DH_SUCCESS, processor_->StopAudioProcessor());
 }
@@ -82,10 +84,11 @@ HWTEST_F(AudioDirectProcessorTest, StartAudioProcessor_001, TestSize.Level1)
  */
 HWTEST_F(AudioDirectProcessorTest, FeedAudioProcessor_001, TestSize.Level1)
 {
+    ASSERT_NE(processor_, nullptr);
     std::shared_ptr<AudioData> inputData = nullptr;
     EXPECT_EQ(ERR_DH_AUDIO_BAD_VALUE, processor_->FeedAudioProcessor(inputData));
     inputData = std::make_shared<AudioData>(4096);
     EXPECT_NE(DH_SUCCESS, processor_->FeedAudioProcessor(inputData));
 }
 } // namespace DistributedHardware
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp
index a174dc0298f1099eaf9a2e0fb1f29f5f35c22e5e..5356029dbbd97bda0cda1c95488dbd8b6ec31de8 100644
--- a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp
+++ b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp
@@ -48,6 +48,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, Initialize_001, TestSize.Level1)
 {
     IAVEngineProvider *providerPtr = nullptr;
     std::string peerDevId = "peerDevId";
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->Initialize(providerPtr, peerDevId));
     receiverAdapter_->initialized_ = true;
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Initialize(providerPtr, peerDevId));
@@ -76,6 +77,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, Initialize_002, TestSize.Level1)
  */
 HWTEST_F(AVReceiverEngineAdapterTest, Start_001, TestSize.Level1)
 {
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->Start());
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->Stop());
 }
@@ -89,6 +91,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, Start_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, SetParameter_001, TestSize.Level1)
 {
     std::string param = "param";
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param));
 }
 
@@ -101,6 +104,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, SetParameter_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, SetParameter_002, TestSize.Level1)
 {
     std::string param = "param";
+    ASSERT_NE(receiverAdapter_, nullptr);
     receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param));
 }
@@ -114,6 +118,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, SetParameter_002, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, CreateControlChannel_001, TestSize.Level1)
 {
     std::string peerDevId = "peerDevId";
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->CreateControlChannel(peerDevId));
     receiverAdapter_->chnCreateSuccess_ = true;
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->CreateControlChannel(peerDevId));
@@ -128,6 +133,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, CreateControlChannel_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, CreateControlChannel_002, TestSize.Level1)
 {
     std::string peerDevId = "peerDevId";
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->CreateControlChannel(peerDevId));
     receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
     EXPECT_EQ(ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED, receiverAdapter_->CreateControlChannel(peerDevId));
@@ -145,6 +151,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, SendMessageToRemote_001, TestSize.Level1)
     std::string content = "content";
     std::string dstDevId = "dstDevId";
     auto message = std::make_shared<AVTransMessage>(type, content, dstDevId);
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->SendMessageToRemote(message));
     receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->SendMessageToRemote(message));
@@ -159,6 +166,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, SendMessageToRemote_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, RegisterAdapterCallback_001, TestSize.Level1)
 {
     std::shared_ptr<AVReceiverAdapterCallback> callback = nullptr;
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverAdapter_->RegisterAdapterCallback(callback));
     callback = std::make_shared<MockAVReceiverAdapterCallback>();
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->RegisterAdapterCallback(callback));
@@ -173,6 +181,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, RegisterAdapterCallback_001, TestSize.Leve
 HWTEST_F(AVReceiverEngineAdapterTest, OnReceiverEvent_001, TestSize.Level1)
 {
     AVTransEvent event;
+    ASSERT_NE(receiverAdapter_, nullptr);
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnReceiverEvent(event));
     std::shared_ptr<AVTransMessage> message = nullptr;
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnMessageReceived(message));
@@ -184,4 +193,4 @@ HWTEST_F(AVReceiverEngineAdapterTest, OnReceiverEvent_001, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnDataAvailable(buffer));
 }
 } // namespace DistributedHardware
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp
index d444ad83e7f146553537d6f51b247f59f5b70f66..20c6e247c669468affa71fe8b6825d6beb76d927 100644
--- a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp
+++ b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp
@@ -51,6 +51,7 @@ HWTEST_F(AVReceiverEngineTransportTest, SetUp_001, TestSize.Level1)
     AudioParam localParam;
     AudioParam remoteParam;
     std::shared_ptr<IAudioDataTransCallback> callback = nullptr;
+    ASSERT_NE(receiverTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
     receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
     EXPECT_EQ(DH_SUCCESS, receiverTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
@@ -65,6 +66,7 @@ HWTEST_F(AVReceiverEngineTransportTest, SetUp_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineTransportTest, InitEngine_001, TestSize.Level1)
 {
     IAVEngineProvider *providerPtr = nullptr;
+    ASSERT_NE(receiverTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->InitEngine(providerPtr));
     receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->InitEngine(providerPtr));
@@ -79,6 +81,7 @@ HWTEST_F(AVReceiverEngineTransportTest, InitEngine_001, TestSize.Level1)
  */
 HWTEST_F(AVReceiverEngineTransportTest, CreateCtrl_001, TestSize.Level1)
 {
+    ASSERT_NE(receiverTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->CreateCtrl());
     receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
     receiverTrans_->receiverAdapter_->chnCreateSuccess_ = true;
@@ -93,6 +96,7 @@ HWTEST_F(AVReceiverEngineTransportTest, CreateCtrl_001, TestSize.Level1)
  */
 HWTEST_F(AVReceiverEngineTransportTest, Start_001, TestSize.Level1)
 {
+    ASSERT_NE(receiverTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Start());
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Stop());
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Release());
@@ -114,6 +118,7 @@ HWTEST_F(AVReceiverEngineTransportTest, Pause_001, TestSize.Level1)
     AudioParam remoteParam;
     size_t bufLen = 4096;
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
+    ASSERT_NE(receiverTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Restart(localParam, remoteParam));
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->Pause());
     EXPECT_EQ(DH_SUCCESS, receiverTrans_->FeedAudioData(audioData));
@@ -131,6 +136,7 @@ HWTEST_F(AVReceiverEngineTransportTest, Pause_002, TestSize.Level1)
     AudioParam remoteParam;
     size_t bufLen = 4096;
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
+    ASSERT_NE(receiverTrans_, nullptr);
     receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
     receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
     EXPECT_EQ(DH_SUCCESS, receiverTrans_->Restart(localParam, remoteParam));
@@ -149,6 +155,7 @@ HWTEST_F(AVReceiverEngineTransportTest, SendMessage_001, TestSize.Level1)
     uint32_t type = 0;
     std::string content = "content";
     std::string dstDevId = "dstDevId";
+    ASSERT_NE(receiverTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SendMessage(type, content, dstDevId));
     receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
     receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
@@ -166,6 +173,7 @@ HWTEST_F(AVReceiverEngineTransportTest, SetParameter_001, TestSize.Level1)
     AVTransEvent event;
     std::shared_ptr<AVTransMessage> message = nullptr;
     std::shared_ptr<AVTransBuffer> buffer = nullptr;
+    ASSERT_NE(receiverTrans_, nullptr);
     receiverTrans_->OnEngineEvent(event);
     receiverTrans_->OnEngineMessage(message);
     receiverTrans_->OnEngineDataAvailable(buffer);
@@ -175,4 +183,4 @@ HWTEST_F(AVReceiverEngineTransportTest, SetParameter_001, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, receiverTrans_->SetParameter(audioParam));
 }
 } // namespace DistributedHardware
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp
index 54dd04947fb2643381d4b5cd6fc6abdd23383680..0da8a7fb8c07908e54572c30bc5c6a95c4dc3f16 100644
--- a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp
+++ b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp
@@ -49,6 +49,7 @@ HWTEST_F(AVSenderEngineAdapterTest, Initialize_001, TestSize.Level1)
 {
     IAVEngineProvider *providerPtr = nullptr;
     std::string peerDevId = "peerDevId";
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->Initialize(providerPtr, peerDevId));
     senderAdapter_->initialized_ = true;
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->Initialize(providerPtr, peerDevId));
@@ -63,6 +64,7 @@ HWTEST_F(AVSenderEngineAdapterTest, Initialize_001, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, Initialize_002, TestSize.Level1)
 {
     std::string peerDevId = "peerDevId";
+    ASSERT_NE(senderAdapter_, nullptr);
     senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->Start());
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->Stop());
@@ -77,6 +79,7 @@ HWTEST_F(AVSenderEngineAdapterTest, Initialize_002, TestSize.Level1)
  */
 HWTEST_F(AVSenderEngineAdapterTest, Release_001, TestSize.Level1)
 {
+    ASSERT_NE(senderAdapter_, nullptr);
     senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngineForFail>();
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->Release());
 }
@@ -89,6 +92,7 @@ HWTEST_F(AVSenderEngineAdapterTest, Release_001, TestSize.Level1)
  */
 HWTEST_F(AVSenderEngineAdapterTest, Start_001, TestSize.Level1)
 {
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->Start());
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->Stop());
 }
@@ -102,6 +106,7 @@ HWTEST_F(AVSenderEngineAdapterTest, Start_001, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, SetParameter_001, TestSize.Level1)
 {
     std::string param = "param";
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param));
 }
 
@@ -114,6 +119,7 @@ HWTEST_F(AVSenderEngineAdapterTest, SetParameter_001, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, SetParameter_002, TestSize.Level1)
 {
     std::string param = "param";
+    ASSERT_NE(senderAdapter_, nullptr);
     senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param));
 }
@@ -127,6 +133,7 @@ HWTEST_F(AVSenderEngineAdapterTest, SetParameter_002, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, PushData_001, TestSize.Level1)
 {
     size_t bufLen = 4096;
+    ASSERT_NE(senderAdapter_, nullptr);
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->PushData(audioData));
     senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
@@ -142,6 +149,7 @@ HWTEST_F(AVSenderEngineAdapterTest, PushData_001, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, CreateControlChannel_001, TestSize.Level1)
 {
     std::string peerDevId = "peerDevId";
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->CreateControlChannel(peerDevId));
     senderAdapter_->chnCreateSuccess_ = true;
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->CreateControlChannel(peerDevId));
@@ -156,6 +164,7 @@ HWTEST_F(AVSenderEngineAdapterTest, CreateControlChannel_001, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, CreateControlChannel_002, TestSize.Level1)
 {
     std::string peerDevId = "peerDevId";
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->CreateControlChannel(peerDevId));
     senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
     EXPECT_EQ(ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED, senderAdapter_->CreateControlChannel(peerDevId));
@@ -170,6 +179,7 @@ HWTEST_F(AVSenderEngineAdapterTest, CreateControlChannel_002, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, WaitForChannelCreated_001, TestSize.Level1)
 {
     senderAdapter_->chnCreateSuccess_ = true;
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->WaitForChannelCreated());
     senderAdapter_->chnCreateSuccess_ = false;
     EXPECT_EQ(ERR_DH_AUDIO_SA_WAIT_TIMEOUT, senderAdapter_->WaitForChannelCreated());
@@ -187,6 +197,7 @@ HWTEST_F(AVSenderEngineAdapterTest, SendMessageToRemote_001, TestSize.Level1)
     std::string content = "content";
     std::string dstDevId = "dstDevId";
     auto message = std::make_shared<AVTransMessage>(type, content, dstDevId);
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->SendMessageToRemote(message));
     senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->SendMessageToRemote(message));
@@ -201,6 +212,7 @@ HWTEST_F(AVSenderEngineAdapterTest, SendMessageToRemote_001, TestSize.Level1)
 HWTEST_F(AVSenderEngineAdapterTest, RegisterAdapterCallback_001, TestSize.Level1)
 {
     std::shared_ptr<AVSenderAdapterCallback> callback = nullptr;
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderAdapter_->RegisterAdapterCallback(callback));
     callback = std::make_shared<MockAVSenderAdapterCallback>();
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->RegisterAdapterCallback(callback));
@@ -215,6 +227,7 @@ HWTEST_F(AVSenderEngineAdapterTest, RegisterAdapterCallback_001, TestSize.Level1
 HWTEST_F(AVSenderEngineAdapterTest, OnSenderEvent_001, TestSize.Level1)
 {
     AVTransEvent event;
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event));
     std::shared_ptr<AVTransMessage> message = nullptr;
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnMessageReceived(message));
@@ -233,10 +246,11 @@ HWTEST_F(AVSenderEngineAdapterTest, OnSenderEvent_002, TestSize.Level1)
 {
     AVTransEvent event;
     event.type = EventType::EVENT_ADD_STREAM;
+    ASSERT_NE(senderAdapter_, nullptr);
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event));
     senderAdapter_->adapterCallback_ = std::make_shared<MockAVSenderAdapterCallback>();
     event.type = EventType::EVENT_START_SUCCESS;
     EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event));
 }
 } // namespace DistributedHardware
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp
index 5c6b908e38aaeba0f7255232fd95f3d51bce046d..1d3b53aa3e1d6a587a2b5cb03129985ec07ca1b0 100644
--- a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp
+++ b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp
@@ -51,6 +51,7 @@ HWTEST_F(AVSenderEngineTransportTest, SetUp_001, TestSize.Level1)
     AudioParam localParam;
     AudioParam remoteParam;
     std::shared_ptr<IAudioDataTransCallback> callback = nullptr;
+    ASSERT_NE(senderTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
     EXPECT_EQ(DH_SUCCESS, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK));
@@ -65,6 +66,7 @@ HWTEST_F(AVSenderEngineTransportTest, SetUp_001, TestSize.Level1)
 HWTEST_F(AVSenderEngineTransportTest, InitEngine_001, TestSize.Level1)
 {
     IAVEngineProvider *providerPtr = nullptr;
+    ASSERT_NE(senderTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->InitEngine(providerPtr));
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->InitEngine(providerPtr));
@@ -79,6 +81,7 @@ HWTEST_F(AVSenderEngineTransportTest, InitEngine_001, TestSize.Level1)
  */
 HWTEST_F(AVSenderEngineTransportTest, CreateCtrl_001, TestSize.Level1)
 {
+    ASSERT_NE(senderTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->CreateCtrl());
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
     senderTrans_->senderAdapter_->chnCreateSuccess_ = true;
@@ -93,6 +96,7 @@ HWTEST_F(AVSenderEngineTransportTest, CreateCtrl_001, TestSize.Level1)
  */
 HWTEST_F(AVSenderEngineTransportTest, Start_001, TestSize.Level1)
 {
+    ASSERT_NE(senderTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Start());
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Stop());
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Release());
@@ -114,6 +118,7 @@ HWTEST_F(AVSenderEngineTransportTest, Pause_001, TestSize.Level1)
     AudioParam remoteParam;
     size_t bufLen = 4096;
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
+    ASSERT_NE(senderTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Restart(localParam, remoteParam));
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->Pause());
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
@@ -132,6 +137,7 @@ HWTEST_F(AVSenderEngineTransportTest, Pause_002, TestSize.Level1)
     AudioParam localParam;
     AudioParam remoteParam;
     size_t bufLen = 4096;
+    ASSERT_NE(senderTrans_, nullptr);
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
     senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
@@ -151,6 +157,7 @@ HWTEST_F(AVSenderEngineTransportTest, SendMessage_001, TestSize.Level1)
     uint32_t type = 0;
     std::string content = "content";
     std::string dstDevId = "dstDevId";
+    ASSERT_NE(senderTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SendMessage(type, content, dstDevId));
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
     senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
@@ -167,6 +174,7 @@ HWTEST_F(AVSenderEngineTransportTest, FeedAudioData_001, TestSize.Level1)
 {
     size_t bufLen = 4096;
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufLen);
+    ASSERT_NE(senderTrans_, nullptr);
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->FeedAudioData(audioData));
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
     senderTrans_->senderAdapter_->senderEngine_ = std::make_shared<MockIAVSenderEngine>();
@@ -183,6 +191,7 @@ HWTEST_F(AVSenderEngineTransportTest, SetParameter_001, TestSize.Level1)
 {
     AVTransEvent event;
     std::shared_ptr<AVTransMessage> message = nullptr;
+    ASSERT_NE(senderTrans_, nullptr);
     senderTrans_->OnEngineEvent(event);
     senderTrans_->OnEngineMessage(message);
     message = std::make_shared<AVTransMessage>();
@@ -193,4 +202,4 @@ HWTEST_F(AVSenderEngineTransportTest, SetParameter_001, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, senderTrans_->SetParameter(audioParam));
 }
 } // namespace DistributedHardware
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/common/test/unittest/audiodata/src/audio_data_test.cpp b/services/common/test/unittest/audiodata/src/audio_data_test.cpp
index c6c496e08824f55fb33c44762b81adb14b1a7a1a..eaa42170bb795906a59633071e38042939ae8957 100644
--- a/services/common/test/unittest/audiodata/src/audio_data_test.cpp
+++ b/services/common/test/unittest/audiodata/src/audio_data_test.cpp
@@ -46,6 +46,7 @@ HWTEST_F(AudioDataTest, SetRange_001, TestSize.Level1)
 {
     size_t offset = 100;
     size_t size = 100;
+    ASSERT_NE(audioData, nullptr);
     int32_t ret = audioData->SetRange(offset, size);
     EXPECT_EQ(ERR_DH_AUDIO_BAD_VALUE, ret);
 }
@@ -60,6 +61,7 @@ HWTEST_F(AudioDataTest, SetRange_002, TestSize.Level1)
 {
     size_t offset = 5;
     size_t size = 5;
+    ASSERT_NE(audioData, nullptr);
     int32_t ret = audioData->SetRange(offset, size);
     EXPECT_EQ(DH_SUCCESS, ret);
 }
@@ -74,6 +76,7 @@ HWTEST_F(AudioDataTest, FindInt32_001, TestSize.Level1)
 {
     const std::string name = "name";
     int32_t value = 1;
+    ASSERT_NE(audioData, nullptr);
     audioData->int32Map_.insert(std::make_pair(name, value));
     EXPECT_EQ(true, audioData->FindInt32(name, value));
 }
@@ -88,6 +91,7 @@ HWTEST_F(AudioDataTest, FindInt32_002, TestSize.Level1)
 {
     const std::string name = "name";
     int32_t value = 1;
+    ASSERT_NE(audioData, nullptr);
     EXPECT_EQ(false, audioData->FindInt32(name, value));
 }
 
@@ -101,6 +105,7 @@ HWTEST_F(AudioDataTest, FindInt64_001, TestSize.Level1)
 {
     const std::string name = "name";
     int64_t value = 1;
+    ASSERT_NE(audioData, nullptr);
     audioData->SetInt64(name, value);
     EXPECT_EQ(true, audioData->FindInt64(name, value));
 }
@@ -115,6 +120,7 @@ HWTEST_F(AudioDataTest, FindInt64_002, TestSize.Level1)
 {
     const std::string name = "name";
     int64_t value = 1;
+    ASSERT_NE(audioData, nullptr);
     EXPECT_EQ(false, audioData->FindInt64(name, value));
 }
 
@@ -128,6 +134,7 @@ HWTEST_F(AudioDataTest, FindString_001, TestSize.Level1)
 {
     const std::string name = "name";
     string value = "value";
+    ASSERT_NE(audioData, nullptr);
     audioData->stringMap_.insert(std::make_pair(name, value));
     EXPECT_EQ(true, audioData->FindString(name, value));
 }
@@ -142,7 +149,8 @@ HWTEST_F(AudioDataTest, FindString_002, TestSize.Level1)
 {
     const std::string name = "name";
     string value = "value";
+    ASSERT_NE(audioData, nullptr);
     EXPECT_EQ(false, audioData->FindString(name, value));
 }
 } // namespace DistributedHardware
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/test_example/distributedaudiotest.cpp b/services/test_example/distributedaudiotest.cpp
index db1833c98bba72a6655de7f90e98d13d850508d5..39ec02c47192e1570bc691ebb68055a572f555e0 100644
--- a/services/test_example/distributedaudiotest.cpp
+++ b/services/test_example/distributedaudiotest.cpp
@@ -288,6 +288,9 @@ static void OpenSpk(const std::string &devId)
     }
 
     g_callbackStub = new AudioParamCallbackImpl();
+    if (g_adapter == nullptr) {
+        return;
+    }
     int32_t ret = g_adapter->RegExtraParamObserver(g_callbackStub, 0);
     if (ret != DH_SUCCESS) {
         std::cout << "Register observer failed, ret: " << ret << std::endl;
@@ -442,12 +445,14 @@ static void CloseSpk()
         StopRender();
     }
 
-    int32_t ret = g_adapter->DestroyRender(g_renderId);
-    if (ret != DH_SUCCESS) {
-        std::cout << "Close speaker failed" << std::endl;
-        return;
+    if (g_adapter != nullptr) {
+        int32_t ret = g_adapter->DestroyRender(g_renderId);
+        if (ret != DH_SUCCESS) {
+            std::cout << "Close speaker failed" << std::endl;
+            return;
+        }
     }
-    if (g_micStatus == DeviceStatus::DEVICE_IDLE) {
+    if (g_micStatus == DeviceStatus::DEVICE_IDLE && g_manager != nullptr) {
         g_manager->UnloadAdapter(g_devId);
         g_adapter = nullptr;
     }
@@ -512,6 +517,9 @@ static void OpenMic(const std::string &devId)
     captureAttr.channelCount = CAPTURE_CHANNEL_MASK;
     captureAttr.sampleRate = AUDIO_SAMPLE_RATE;
     captureAttr.format = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
+    if (g_adapter == nullptr) {
+        return;
+    }
     int32_t ret = g_adapter->CreateCapture(captureDesc, captureAttr, g_capture, g_captureId);
     if (ret != DH_SUCCESS || g_capture == nullptr) {
         std::cout << "Open MIC device failed." << std::endl;
@@ -628,12 +636,14 @@ static void CloseMic()
         StopCapture();
     }
 
-    int32_t ret = g_adapter->DestroyCapture(g_captureId);
-    if (ret != DH_SUCCESS) {
-        std::cout << "Close mic failed." << std::endl;
-        return;
+    if (g_adapter != nullptr) {
+        int32_t ret = g_adapter->DestroyCapture(g_captureId);
+        if (ret != DH_SUCCESS) {
+            std::cout << "Close mic failed." << std::endl;
+            return;
+        }
     }
-    if (g_spkStatus == DeviceStatus::DEVICE_IDLE) {
+    if (g_spkStatus == DeviceStatus::DEVICE_IDLE && g_manager != nullptr) {
         g_manager->UnloadAdapter(g_devId);
         g_adapter = nullptr;
     }
@@ -661,9 +671,11 @@ static void SetVolume()
     AudioExtParamKey key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_VOLUME;
     std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=1;AUDIO_VOLUME_TYPE=1;";
     std::string volStr = std::to_string(volInt);
+    if (g_adapter != nullptr) {
     int32_t ret = g_adapter->SetExtraParams(key, condition, volStr);
-    if (ret != DH_SUCCESS) {
-        std::cout << "Set volume failed" << std::endl;
+        if (ret != DH_SUCCESS) {
+            std::cout << "Set volume failed" << std::endl;
+        }
     }
 }
 
@@ -676,10 +688,12 @@ static void GetVolume()
     AudioExtParamKey key = AudioExtParamKey::AUDIO_EXT_PARAM_KEY_VOLUME;
     std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=1;AUDIO_VOLUME_TYPE=1;";
     std::string vol;
-    int32_t ret = g_adapter->GetExtraParams(key, condition.c_str(), vol);
-    if (ret != DH_SUCCESS) {
-        std::cout << "Get Volume failed." << std::endl;
-        return;
+    if (g_adapter != nullptr) {
+        int32_t ret = g_adapter->GetExtraParams(key, condition.c_str(), vol);
+        if (ret != DH_SUCCESS) {
+            std::cout << "Get Volume failed." << std::endl;
+            return;
+        }
     }
     std::cout << "Get volume success. volume: " << vol <<std::endl;
 }