diff --git a/services/channel/src/dcamera_channel_source_impl.cpp b/services/channel/src/dcamera_channel_source_impl.cpp
index d772283350660f55b2d1aa3e36edb504ae172291..0a3eec3889969d40a0ebd59df05225f70d9dd166 100644
--- a/services/channel/src/dcamera_channel_source_impl.cpp
+++ b/services/channel/src/dcamera_channel_source_impl.cpp
@@ -41,6 +41,9 @@ int32_t DCameraChannelSourceImpl::CloseSession()
     }
     int32_t ret = DCAMERA_OK;
     for (auto iter = softbusSessions_.begin(); iter != softbusSessions_.end(); iter++) {
+        if ((*iter) == nullptr) {
+            continue;
+        }
         int32_t retOpen = (*iter)->CloseSession();
         if (retOpen != DCAMERA_OK) {
             DHLOGE("DCameraChannelSourceImpl CloseSession %{public}s failed, ret: %{public}d",
@@ -96,6 +99,9 @@ int32_t DCameraChannelSourceImpl::ReleaseSession()
 {
     DHLOGI("DCameraChannelSourceImpl ReleaseSession name: %{public}s", GetAnonyString(mySessionName_).c_str());
     for (auto iter = softbusSessions_.begin(); iter != softbusSessions_.end(); iter++) {
+        if ((*iter) == nullptr) {
+            continue;
+        }
         std::string sessKey = (*iter)->GetPeerDevId() + (*iter)->GetPeerSessionName();
         DCameraSoftbusAdapter::GetInstance().sourceSessions_.erase(sessKey);
     }
@@ -116,6 +122,9 @@ int32_t DCameraChannelSourceImpl::SendData(std::shared_ptr<DataBuffer>& buffer)
     }
     int32_t ret = DCAMERA_OK;
     for (auto iter = softbusSessions_.begin(); iter != softbusSessions_.end(); iter++) {
+        if ((*iter) == nullptr) {
+            continue;
+        }
         int32_t retSend = (*iter)->SendData(mode_, buffer);
         if (retSend != DCAMERA_OK) {
             DHLOGE("DCameraChannelSourceImpl SendData %{public}s failed, ret: %{public}d",
diff --git a/services/channel/src/dcamera_softbus_adapter.cpp b/services/channel/src/dcamera_softbus_adapter.cpp
index 96a4be39e4b364958a41426c39cacbd01324ec06..59d499d79f47e9c37b59d42df1bae9f01fd56b73 100644
--- a/services/channel/src/dcamera_softbus_adapter.cpp
+++ b/services/channel/src/dcamera_softbus_adapter.cpp
@@ -239,11 +239,13 @@ int32_t DCameraSoftbusAdapter::CloseSoftbusSession(int32_t socket)
 
 int32_t DCameraSoftbusAdapter::SendSofbusBytes(int32_t socket, std::shared_ptr<DataBuffer>& buffer)
 {
+    CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
     return SendBytes(socket, buffer->Data(), buffer->Size());
 }
 
 int32_t DCameraSoftbusAdapter::SendSofbusStream(int32_t socket, std::shared_ptr<DataBuffer>& buffer)
 {
+    CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
     StreamData streamData = { reinterpret_cast<char *>(buffer->Data()), buffer->Size() };
     int64_t timeStamp;
     if (!buffer->FindInt64(TIME_STAMP_US, timeStamp)) {
@@ -317,11 +319,10 @@ int32_t DCameraSoftbusAdapter::SourceOnBind(int32_t socket, PeerSocketInfo info)
     DHLOGI("source bind socket begin, socket: %{public}d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("source bind socket can not find socket %{public}d", socket);
         return DCAMERA_NOT_FOUND;
     }
-
     ret = session->OnSessionOpened(socket);
     if (ret != DCAMERA_OK) {
         DHLOGE("source bind socket failed, ret: %{public}d socket: %{public}d", ret, socket);
@@ -338,7 +339,7 @@ void DCameraSoftbusAdapter::SourceOnShutDown(int32_t socket, ShutdownReason reas
     DHLOGI("source on shutdown socket start, socket: %{public}d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusGetSessionById(socket, session);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("SourceOnShutDown can not find socket %{public}d", socket);
         return;
     }
@@ -360,7 +361,7 @@ void DCameraSoftbusAdapter::SourceOnBytes(int32_t socket, const void *data, uint
     DHLOGI("source callback send bytes start, socket: %{public}d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("source callback send bytes not find session %{public}d", socket);
         return;
     }
@@ -399,7 +400,7 @@ void DCameraSoftbusAdapter::SourceOnStream(int32_t socket, const StreamData *dat
     }
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("SourceOnStream not find socket %{public}d", socket);
         return;
     }
@@ -438,6 +439,7 @@ int32_t DCameraSoftbusAdapter::HandleSourceStreamExt(std::shared_ptr<DataBuffer>
         return DCAMERA_BAD_VALUE;
     }
     int64_t recvT;
+    CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
     if (!buffer->FindInt64(RECV_TIME_US, recvT)) {
         DHLOGD("HandleSourceStreamExt find %{public}s failed.", RECV_TIME_US.c_str());
     }
@@ -483,6 +485,7 @@ int32_t DCameraSoftbusAdapter::DCameraSoftbusSinkGetSession(int32_t socket,
             return DCAMERA_NOT_FOUND;
         }
         session = iter->second;
+        CHECK_AND_RETURN_RET_LOG(session == nullptr, DCAMERA_BAD_VALUE, "Softbus session is null");
         if (session->GetSessionId() < 0) {
             DHLOGE("sink find session error, current sessionId is invalid");
             return DCAMERA_BAD_VALUE;
@@ -527,11 +530,10 @@ int32_t DCameraSoftbusAdapter::SinkOnBind(int32_t socket, PeerSocketInfo info)
     DHLOGI("sink bind socket start, socket: %{public}d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftBusGetSessionByPeerSocket(socket, session, info);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("sink bind socket error, can not find socket %{public}d", socket);
         return DCAMERA_NOT_FOUND;
     }
-
     ret = session->OnSessionOpened(socket);
     if (ret != DCAMERA_OK) {
         DHLOGE("sink bind socket error, not find socket %{public}d", socket);
@@ -548,7 +550,7 @@ void DCameraSoftbusAdapter::SinkOnShutDown(int32_t socket, ShutdownReason reason
     DHLOGI("sink on shutdown socket start, socket: %{public}d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusGetSessionById(socket, session);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("sink on shutdown socket can not find socket %{public}d", socket);
         return;
     }
@@ -570,7 +572,7 @@ void DCameraSoftbusAdapter::SinkOnBytes(int32_t socket, const void *data, uint32
     DHLOGI("sink on bytes start, socket: %{public}d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSinkGetSession(socket, session);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("sink on bytes error, can not find session %{public}d", socket);
         return;
     }
@@ -604,7 +606,7 @@ void DCameraSoftbusAdapter::SinkOnStream(int32_t socket, const StreamData *data,
     }
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSinkGetSession(socket, session);
-    if (ret != DCAMERA_OK) {
+    if (ret != DCAMERA_OK || session == nullptr) {
         DHLOGE("SinkOnStream error, can not find socket %{public}d", socket);
         return;
     }
diff --git a/services/channel/src/dcamera_softbus_latency.cpp b/services/channel/src/dcamera_softbus_latency.cpp
index 07f8b0bf896c70d63812090cb92958adf403c6d6..87322aaefa8d9187c68ca88ede734675f59e8477 100644
--- a/services/channel/src/dcamera_softbus_latency.cpp
+++ b/services/channel/src/dcamera_softbus_latency.cpp
@@ -31,6 +31,10 @@ constexpr static int32_t MICROSECONDS = 1000;
 
 static void OnTimeSyncResult(const TimeSyncResultInfo *info, int32_t retCode)
 {
+    if (info == nullptr) {
+        DHLOGE("Camera info is null");
+        return;
+    }
     int32_t microsecond = info->result.millisecond * MICROSECONDS + info->result.microsecond;
     DHLOGD("DCameraSoftbusLatency OnTimeSyncResult retcode %{public}d, millisecond: %{public}d, microsecond %{public}d "
         "microsecond_ %{public}d", retCode, info->result.millisecond, info->result.microsecond, microsecond);
diff --git a/services/channel/src/dcamera_softbus_session.cpp b/services/channel/src/dcamera_softbus_session.cpp
index 47a86d0f567e36b7afeefa2af7ffeb14fc7f7e93..fe6de56c6775a624599c74fa914660b7902aaca6 100644
--- a/services/channel/src/dcamera_softbus_session.cpp
+++ b/services/channel/src/dcamera_softbus_session.cpp
@@ -127,6 +127,10 @@ void DCameraSoftbusSession::DealRecvData(std::shared_ptr<DataBuffer>& buffer)
 
 void DCameraSoftbusSession::PackRecvData(std::shared_ptr<DataBuffer>& buffer)
 {
+    if (buffer == nullptr) {
+        DHLOGE("Data buffer is null");
+        return;
+    }
     uint64_t bufferSize;
     if (buffer->Size() < BINARY_HEADER_FRAG_LEN) {
         bufferSize = static_cast<uint64_t>(buffer->Size());
@@ -166,6 +170,10 @@ void DCameraSoftbusSession::AssembleNoFrag(std::shared_ptr<DataBuffer>& buffer,
             peerSessionName_.c_str());
         return;
     }
+    if (buffer == nullptr) {
+        DHLOGE("Data buffer is null");
+        return;
+    }
     std::shared_ptr<DataBuffer> postData = std::make_shared<DataBuffer>(headerPara.dataLen);
     int32_t ret = memcpy_s(postData->Data(), postData->Size(), buffer->Data() + BINARY_HEADER_FRAG_LEN,
         buffer->Size() - BINARY_HEADER_FRAG_LEN);
@@ -179,6 +187,10 @@ void DCameraSoftbusSession::AssembleNoFrag(std::shared_ptr<DataBuffer>& buffer,
 
 void DCameraSoftbusSession::AssembleFrag(std::shared_ptr<DataBuffer>& buffer, SessionDataHeader& headerPara)
 {
+    if (buffer == nullptr) {
+        DHLOGE("Data buffer is null");
+        return;
+    }
     if (headerPara.fragFlag == FRAG_START) {
         isWaiting_ = true;
         nowSeq_ = headerPara.seqNum;
@@ -313,6 +325,7 @@ int32_t DCameraSoftbusSession::SendData(DCameraSessionMode mode, std::shared_ptr
 
 int32_t DCameraSoftbusSession::UnPackSendData(std::shared_ptr<DataBuffer>& buffer, DCameraSendFuc memberFunc)
 {
+    CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
     uint16_t subSeq = 0;
     uint32_t seq = 0;
     uint32_t totalLen = buffer->Size();
diff --git a/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp b/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp
index 6e4acda2eb092a6efbe6ac70ca27b6faffd7e297..c603d8e81227f55a156b05f74c913e290482cf4b 100644
--- a/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp
+++ b/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp
@@ -81,6 +81,7 @@ void DCameraChannelSinkImplTest::TearDown(void)
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_001, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -104,6 +105,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_001, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_002, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -128,6 +130,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_002, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_003, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -153,6 +156,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_003, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_004, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -183,6 +187,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_004, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_006, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     int32_t ret = channel_->CloseSession();
     EXPECT_EQ(DCAMERA_BAD_OPERATE, ret);
 }
@@ -195,6 +200,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_006, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_007, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     int32_t ret = channel_->ReleaseSession();
     EXPECT_EQ(DCAMERA_OK, ret);
 }
@@ -207,6 +213,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_007, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_008, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
     int32_t ret = channel_->SendData(dataBuffer);
@@ -222,6 +229,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_008, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_009, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -243,6 +251,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_009, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_010, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     operator_ = std::make_shared<MockCameraOperator>();
     output_ = std::make_shared<DCameraSinkOutput>(TEST_CAMERA_DH_ID_0, operator_);
     listener_ = std::make_shared<DCameraSinkOutputChannelListener>(CONTINUOUS_FRAME, output_);
@@ -269,6 +278,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_010, TestSiz
  */
 HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_011, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
diff --git a/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp b/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp
index 5dcf82d3c628283dc2505c650c43e4429afb2e39..37d26e3f52fa50719c1e36bcd4c1f29d1788dc9a 100644
--- a/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp
+++ b/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp
@@ -84,6 +84,7 @@ void DCameraChannelSourceImplTest::TearDown(void)
  */
 HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_001, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -109,6 +110,7 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_001, Tes
  */
 HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_002, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -135,6 +137,7 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_002, Tes
  */
 HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_003, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
@@ -165,6 +168,7 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_003, Tes
  */
 HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_006, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     int32_t ret = channel_->CloseSession();
     EXPECT_EQ(DCAMERA_BAD_OPERATE, ret);
 }
@@ -177,6 +181,7 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_006, Tes
  */
 HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_007, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     int32_t ret = channel_->ReleaseSession();
     EXPECT_EQ(DCAMERA_OK, ret);
 }
@@ -189,6 +194,7 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_007, Tes
  */
 HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_008, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
     int32_t ret = channel_->SendData(dataBuffer);
@@ -204,6 +210,7 @@ HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_008, Tes
  */
 HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_009, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, channel_);
     std::vector<DCameraIndex> camIndexs;
     DCameraIndex index;
     index.devId_ = TEST_DEVICE_ID;
diff --git a/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
index ace920ca11ee296772459daa7c5c98ffb72f1414..89165202eae6fb9f4bc740a0e3a1fcc529968dc0 100644
--- a/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
+++ b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
@@ -94,6 +94,7 @@ void DCameraSoftbusSessionTest::TearDown(void)
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_001, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     softbusSession_->sessionId_ = 2;
     int32_t ret = softbusSession_->CloseSession();
     EXPECT_EQ(DCAMERA_OK, ret);
@@ -108,6 +109,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_001, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_002, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     int32_t sessionId = 1;
     std::string sessionName = "dcamera_softbus_session_test_002";
     std::string pkgName = "ohos.dhardware.dcamera";
@@ -124,6 +126,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_002, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_003, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
     std::string mySessionName = "testmysession";
@@ -142,6 +145,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_003, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_004, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
     softbusSession_->mode_ = DCAMERA_SESSION_MODE_VIDEO;
@@ -161,6 +165,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_004, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_005, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t capacity = 1;
     size_t offset = 0;
     size_t size = 22;
@@ -182,6 +187,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_005, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_006, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
     DCameraSoftbusSession::SessionDataHeader headerPara;
@@ -202,6 +208,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_006, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_007, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
     DCameraSoftbusSession::SessionDataHeader headerPara;
@@ -232,6 +239,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_007, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_008, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     DCameraSoftbusSession::SessionDataHeader headerPara;
     headerPara.dataLen = 1;
     headerPara.totalLen = 2;
@@ -262,6 +270,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_008, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_009, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     DCameraSoftbusSession::SessionDataHeader headerPara;
     headerPara.dataLen = 1;
     headerPara.totalLen = 2;
@@ -283,6 +292,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_009, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_010, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     DCameraSessionMode mode = DCAMERA_SESSION_MODE_VIDEO;
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
@@ -304,6 +314,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_010, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_011, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t offset = 1;
     size_t size = DCameraSoftbusSession::BINARY_DATA_PACKET_MAX_LEN - 10;
     size_t capacity = size;
@@ -324,6 +335,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_011, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_012, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     DCameraSoftbusSession::SessionDataHeader headerPara;
     headerPara.dataLen = 1;
     headerPara.totalLen = 2;
@@ -347,6 +359,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_012, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_013, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
     softbusSession_->state_ = DCAMERA_SOFTBUS_STATE_OPENED;
@@ -364,6 +377,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_013, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_014, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
     softbusSession_->state_ = DCAMERA_SOFTBUS_STATE_OPENED;
@@ -382,6 +396,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_014, TestSize.L
  */
 HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_015, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, softbusSession_);
     int32_t sessionId = 1;
     int32_t ret = softbusSession_->OnSessionClose(sessionId);
     EXPECT_EQ(DCAMERA_OK, ret);
diff --git a/services/data_process/src/pipeline/dcamera_pipeline_sink.cpp b/services/data_process/src/pipeline/dcamera_pipeline_sink.cpp
index ef3388d3f7fe929833d6a8318461e2a2d5ecbd4c..c31033052bc1b2dbe4c96f268ffd15956fa53ef8 100644
--- a/services/data_process/src/pipeline/dcamera_pipeline_sink.cpp
+++ b/services/data_process/src/pipeline/dcamera_pipeline_sink.cpp
@@ -94,6 +94,7 @@ int32_t DCameraPipelineSink::InitDCameraPipNodes(const VideoConfigParams& source
 
     VideoConfigParams curNodeSourceCfg = sourceConfig;
     for (size_t i = 0; i < pipNodeRanks_.size(); i++) {
+        CHECK_AND_RETURN_RET_LOG((pipNodeRanks_[i] == nullptr), DCAMERA_BAD_VALUE, "Node is null.");
         pipNodeRanks_[i]->SetNodeRank(i);
 
         VideoConfigParams curNodeProcessedCfg;
diff --git a/services/data_process/src/pipeline/dcamera_pipeline_source.cpp b/services/data_process/src/pipeline/dcamera_pipeline_source.cpp
index 387f102a7316a04da344ecada86d8675877c62d7..5a5b38235b48a77f520cde02bd849315f2f5ae6d 100644
--- a/services/data_process/src/pipeline/dcamera_pipeline_source.cpp
+++ b/services/data_process/src/pipeline/dcamera_pipeline_source.cpp
@@ -95,6 +95,10 @@ void DCameraPipelineSource::StartEventHandler()
 {
     prctl(PR_SET_NAME, PIPELINE_SRC_EVENT.c_str());
     auto runner = AppExecFwk::EventRunner::Create(false);
+    if (runner == nullptr) {
+        DHLOGE("Creat runner failed.");
+        return;
+    }
     {
         std::lock_guard<std::mutex> lock(eventMutex_);
         pipeEventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
@@ -126,6 +130,7 @@ int32_t DCameraPipelineSource::InitDCameraPipNodes(const VideoConfigParams& sour
 
     VideoConfigParams curNodeSourceCfg = sourceConfig;
     for (size_t i = 0; i < pipNodeRanks_.size(); i++) {
+        CHECK_AND_RETURN_RET_LOG((pipNodeRanks_[i] == nullptr), DCAMERA_BAD_VALUE, "Node is null.");
         pipNodeRanks_[i]->SetNodeRank(i);
         DHLOGI("DCameraPipelineSource::InitDCameraPipNodes Node %{public}zu Source Config: width %{public}d height "
             "%{public}d format %{public}d codecType %{public}d frameRate %{public}d", i, curNodeSourceCfg.GetWidth(),
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp
index 4f2f5c75942710c7df54148f6eb8cd2d01710333..aec9b900b767eff77bb2baef7e0ca7ddd923d52b 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp
@@ -106,6 +106,10 @@ void DecodeDataProcess::StartEventHandler()
 {
     prctl(PR_SET_NAME, DECODE_DATA_EVENT.c_str());
     auto runner = AppExecFwk::EventRunner::Create(false);
+    if (runner == nullptr) {
+        DHLOGE("Creat runner failed.");
+        return;
+    }
     {
         std::lock_guard<std::mutex> lock(eventMutex_);
         decEventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp
index 4d1e6be5d19284c293b487793f341df5209c7bab..fdbb0c43a1a3d3e4c37613f6ffffa7baaaf7bb2b 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process_common.cpp
@@ -106,6 +106,10 @@ void DecodeDataProcess::StartEventHandler()
 {
     prctl(PR_SET_NAME, DECODE_DATA_EVENT.c_str());
     auto runner = AppExecFwk::EventRunner::Create(false);
+    if (runner == nullptr) {
+        DHLOGE("Creat runner failed.");
+        return;
+    }
     {
         std::lock_guard<std::mutex> lock(eventMutex_);
         decEventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
index bd278254ecead9e2720679c7f70d3e0ffeb4f4f7..26a6f59b0e57fb8265747fc0dced45e995397851 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
@@ -365,6 +365,10 @@ int32_t EncodeDataProcess::FeedEncoderInputBuffer(std::shared_ptr<DataBuffer>& i
     inputTimeStampUs_ = GetEncoderTimeStamp();
     DHLOGD("Encoder input buffer size %{public}zu, timeStamp %{public}lld.", inputBuffer->Size(),
         (long long)inputTimeStampUs_);
+    if (surfacebuffer->GetExtraData() == nullptr) {
+        DHLOGE("Surface buffer exist null extra data.");
+        return DCAMERA_BAD_OPERATE;
+    }
     surfacebuffer->GetExtraData()->ExtraSet("timeStamp", inputTimeStampUs_);
 
     BufferFlushConfig flushConfig = { {0, 0, sourceConfig_.GetWidth(), sourceConfig_.GetHeight()}, 0};
@@ -401,6 +405,10 @@ sptr<SurfaceBuffer> EncodeDataProcess::GetEncoderInputSurfaceBuffer()
     }
     sptr<SurfaceBuffer> surfacebuffer = nullptr;
     int32_t flushFence = -1;
+    if (encodeProducerSurface_ == nullptr) {
+        DHLOGE("Encode producer surface is null.");
+        return nullptr;
+    }
     GSError err = encodeProducerSurface_->RequestBuffer(surfacebuffer, flushFence, requestConfig);
     if (err != GSERROR_OK || surfacebuffer == nullptr) {
         DHLOGE("Request encoder input producer surface buffer failed, error code: %d.", err);
diff --git a/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process.cpp b/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process.cpp
index 595bebfc88e065066efadf65e6d3ff483f8134a5..797fda00bddebb24ced76aa6896ca4f3957aa0ef 100644
--- a/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process.cpp
+++ b/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process.cpp
@@ -267,7 +267,7 @@ int32_t ScaleConvertProcess::ConvertResolution(ImageUnitInfo& srcImgInfo, ImageU
         DHLOGD("Convert I420 Scale: srcImgInfo is the same as dstImgInfo");
         return DCAMERA_OK;
     }
-
+    CHECK_AND_RETURN_RET_LOG((srcImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Data buffer exists null data");
     DHLOGD("Convert I420 Scale: format=%{public}d, width=[%{public}d, %{public}d], height=[%{public}d, %{public}d]",
         srcImgInfo.colorFormat, srcImgInfo.width, srcImgInfo.alignedWidth, srcImgInfo.height, srcImgInfo.alignedHeight);
     int srcSizeY = srcImgInfo.width * srcImgInfo.height;
@@ -315,6 +315,8 @@ int32_t ScaleConvertProcess::ConvertResolution(ImageUnitInfo& srcImgInfo, ImageU
 int32_t ScaleConvertProcess::ConvertFormatToNV21(ImageUnitInfo& srcImgInfo, ImageUnitInfo& dstImgInfo,
     std::shared_ptr<DataBuffer>& dstBuf)
 {
+    CHECK_AND_RETURN_RET_LOG((dstBuf == nullptr), DCAMERA_BAD_VALUE, "Buffer is null.");
+    CHECK_AND_RETURN_RET_LOG((dstImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Image data is null.");
     if (srcImgInfo.colorFormat == dstImgInfo.colorFormat) {
         DHLOGD("Convert format to NV21 srcImgInfo format is the same as dstImgInfo format");
         return DCAMERA_OK;
@@ -355,6 +357,8 @@ int32_t ScaleConvertProcess::ConvertFormatToNV21(ImageUnitInfo& srcImgInfo, Imag
 int32_t ScaleConvertProcess::ConvertFormatToRGBA(ImageUnitInfo& srcImgInfo, ImageUnitInfo& dstImgInfo,
     std::shared_ptr<DataBuffer>& dstBuf)
 {
+    CHECK_AND_RETURN_RET_LOG((dstBuf == nullptr), DCAMERA_BAD_VALUE, "Buffer is null.");
+    CHECK_AND_RETURN_RET_LOG((dstImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Image data is null.");
     if (srcImgInfo.colorFormat == dstImgInfo.colorFormat) {
         DHLOGD("Convert format to RGBA srcImgInfo format is the same as dstImgInfo format");
         return DCAMERA_OK;
diff --git a/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process_common.cpp b/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process_common.cpp
index 53edb7559f144962f875f08f43a1ee393ef04015..b43bc9f2cbedf6e8f1b24abf47f0b49da14d6d41 100644
--- a/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process_common.cpp
+++ b/services/data_process/src/pipeline_node/scale_conversion/scale_convert_process_common.cpp
@@ -303,6 +303,7 @@ int32_t ScaleConvertProcess::ScaleConvert(ImageUnitInfo& srcImgInfo, ImageUnitIn
 
 int32_t ScaleConvertProcess::CopyYUV420SrcData(const ImageUnitInfo& srcImgInfo)
 {
+    CHECK_AND_RETURN_RET_LOG((srcImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Data buffer exists null data");
     int32_t ret = memcpy_s(srcData_[0], srcImgInfo.width * srcImgInfo.height,
         srcImgInfo.imgData->Data(), srcImgInfo.width * srcImgInfo.height);
     if (ret != EOK) {
@@ -331,6 +332,7 @@ int32_t ScaleConvertProcess::CopyYUV420SrcData(const ImageUnitInfo& srcImgInfo)
 
 int32_t ScaleConvertProcess::CopyNV12SrcData(const ImageUnitInfo& srcImgInfo)
 {
+    CHECK_AND_RETURN_RET_LOG((srcImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Data buffer exists null data");
     int32_t ret = memcpy_s(srcData_[0], srcImgInfo.width * srcImgInfo.height,
         srcImgInfo.imgData->Data(), srcImgInfo.width * srcImgInfo.height);
     if (ret != EOK) {
@@ -350,6 +352,7 @@ int32_t ScaleConvertProcess::CopyNV12SrcData(const ImageUnitInfo& srcImgInfo)
 
 int32_t ScaleConvertProcess::CopyNV21SrcData(const ImageUnitInfo& srcImgInfo)
 {
+    CHECK_AND_RETURN_RET_LOG((srcImgInfo.imgData == nullptr), DCAMERA_BAD_VALUE, "Data buffer exists null data");
     int32_t ret = memcpy_s(srcData_[0], srcImgInfo.width * srcImgInfo.height,
         srcImgInfo.imgData->Data(), srcImgInfo.width * srcImgInfo.height);
     if (ret != EOK) {
diff --git a/services/data_process/test/unittest/common/pipeline_node/scale_convert_process_test.cpp b/services/data_process/test/unittest/common/pipeline_node/scale_convert_process_test.cpp
index 764a57283210a367c78ec7c810d0b630b796b5e3..99d322e421a382f3b65c006c9e4fc231d715d699 100644
--- a/services/data_process/test/unittest/common/pipeline_node/scale_convert_process_test.cpp
+++ b/services/data_process/test/unittest/common/pipeline_node/scale_convert_process_test.cpp
@@ -88,6 +88,7 @@ VideoConfigParams PROC_CONFIG;
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_001, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS1, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 }
@@ -100,6 +101,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_001, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_002, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS2, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 }
@@ -112,6 +114,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_002, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_003, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     std::vector<std::shared_ptr<DataBuffer>> inputBuffers;
     int32_t rc = testScaleConvertProcess_->ProcessData(inputBuffers);
     EXPECT_EQ(rc, DCAMERA_DISABLE_PROCESS);
@@ -125,6 +128,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_003, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_004, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS1, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -141,6 +145,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_004, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_005, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS1, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -160,6 +165,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_005, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_006, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS2, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -179,6 +185,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_006, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_007, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS2, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -207,6 +214,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_007, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_008, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS2, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -228,6 +236,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_008, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_009, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::YUVI420, 0, 0, 0, 0, 0, 0, nullptr};
     std::shared_ptr<DataBuffer> imgBuf = nullptr;
     int32_t rc = testScaleConvertProcess_->GetImageUnitInfo(srcImgInfo, imgBuf);
@@ -251,6 +260,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_009, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_010, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::YUVI420, 0, 0, 0, 0, 0, 0, nullptr};
     size_t capacity = 100;
     std::shared_ptr<DataBuffer> imgBuf = std::make_shared<DataBuffer>(capacity);
@@ -273,6 +283,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_010, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_011, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::YUVI420, 0, 0, 0, 0, 0, 0, nullptr};
     size_t capacity = 100;
     std::shared_ptr<DataBuffer> imgBuf = std::make_shared<DataBuffer>(capacity);
@@ -296,6 +307,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_011, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_012, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, nullptr};
     ImageUnitInfo dstImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, nullptr};
 
@@ -317,6 +329,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_012, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_013, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     std::shared_ptr<DataBuffer> imgData = std::make_shared<DataBuffer>(10);
     ImageUnitInfo srcImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, imgData};
     ImageUnitInfo dstImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, imgData};
@@ -333,6 +346,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_013, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_014, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, nullptr};
     ImageUnitInfo dstImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, nullptr};
 
@@ -348,6 +362,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_014, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_015, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {};
     std::shared_ptr<DataBuffer> dtBuf = std::make_shared<DataBuffer>(10);
     srcImgInfo.alignedWidth = TEST_WIDTH2;
@@ -369,6 +384,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_015, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_016, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     Videoformat colorFormat = Videoformat::NV21;
     AVPixelFormat f = testScaleConvertProcess_->GetAVPixelFormat(colorFormat);
     colorFormat = Videoformat::RGBA_8888;
@@ -386,6 +402,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_016, TestSize.Level
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_017, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     Videoformat colorFormat = Videoformat::NV12;
     AVPixelFormat f = testScaleConvertProcess_->GetAVPixelFormat(colorFormat);
     EXPECT_EQ(f, AVPixelFormat::AV_PIX_FMT_NV12);
@@ -442,6 +459,7 @@ VideoConfigParams PROC_CONFIG;
  */
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_018, TestSize.Level1)
 {
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_018.");
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS1, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
@@ -456,6 +474,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_018, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_019, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_019.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     std::vector<std::shared_ptr<DataBuffer>> inputBuffers;
     int32_t rc = testScaleConvertProcess_->ProcessData(inputBuffers);
     EXPECT_EQ(rc, DCAMERA_DISABLE_PROCESS);
@@ -470,6 +489,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_019, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_020, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_020.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::YUVI420, 0, 0, 0, 0, 0, 0, nullptr};
     std::shared_ptr<DataBuffer> imgBuf = nullptr;
     int32_t rc = testScaleConvertProcess_->GetImageUnitInfo(srcImgInfo, imgBuf);
@@ -494,6 +514,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_020, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_021, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_021.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::YUVI420, 0, 0, 0, 0, 0, 0, nullptr};
     size_t capacity = 100;
     std::shared_ptr<DataBuffer> imgBuf = std::make_shared<DataBuffer>(capacity);
@@ -518,6 +539,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_021, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_022, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_022.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, nullptr};
     ImageUnitInfo dstImgInfo {Videoformat::NV12, TEST_WIDTH, TEST_HEIGTH, 0, 0, 0, 0, nullptr};
 
@@ -540,6 +562,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_022, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_023, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_023.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     ImageUnitInfo srcImgInfo {Videoformat::YUVI420, 0, 0, 0, 0, 0, 0, nullptr};
     size_t capacity = 100;
     std::shared_ptr<DataBuffer> imgBuf = std::make_shared<DataBuffer>(capacity);
@@ -563,6 +586,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_023, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_024, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_024.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS1, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -580,6 +604,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_024, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_025, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_025.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS1, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -600,6 +625,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_025, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_026, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_026.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS2, PROC_CONFIG);
     testScaleConvertProcess_->isScaleConvert_.store(false);
     EXPECT_EQ(rc, DCAMERA_OK);
@@ -630,6 +656,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_026, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_027, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_027.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS2, PROC_CONFIG);
     EXPECT_EQ(rc, DCAMERA_OK);
 
@@ -655,6 +682,7 @@ HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_027, TestSize.Level
 HWTEST_F(ScaleConvertProcessTest, scale_convert_process_test_028, TestSize.Level1)
 {
     DHLOGI("ScaleConvertProcessTest scale_convert_process_test_028.");
+    EXPECT_NE(nullptr, testScaleConvertProcess_);
     int32_t rc = testScaleConvertProcess_->InitNode(SRC_PARAMS1, DEST_PARAMS3, PROC_CONFIG);
     testScaleConvertProcess_->isScaleConvert_.store(false);
     EXPECT_EQ(rc, DCAMERA_OK);