!817 DMS雷达打点UT

Merge pull request !817 from liuxiaowei42/master
2025-02-21 15:01:20 +00:00 · 2024-03-16 09:59:36 +00:00 · 2024-03-16 09:59:36 +00:00 · 8afed98bbc
commit 8afed98bbc
parent 59c720b193 97cdbedd85
3 changed files with 693 additions and 0 deletions
--- a/services/dtbschedmgr/test/BUILD.gn
+++ b/services/dtbschedmgr/test/BUILD.gn
@ -193,6 +193,7 @@ ohos_unittest("distributedschedsvrtest") {
  ]

  sources = [
+    "unittest/distributed_radar_test.cpp",
    "unittest/distributed_sched_adapter_test.cpp",
    "unittest/distributed_sched_dumper_test.cpp",
    "unittest/distributed_sched_service_first_test.cpp",
--- a/services/dtbschedmgr/test/unittest/distributed_radar_test.cpp
+++ b/services/dtbschedmgr/test/unittest/distributed_radar_test.cpp
@ -0,0 +1,655 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "distributed_radar_test.h"
+
+using namespace testing;
+using namespace testing::ext;
+
+namespace OHOS {
+namespace DistributedSchedule {
+
+void DistributedRadarTest::SetUpTestCase()
+{
+    DTEST_LOG << "DistributedRadarTest::SetUpTestCase" << std::endl;
+}
+
+void DistributedRadarTest::TearDownTestCase()
+{
+    DTEST_LOG << "DistributedRadarTest::TearDownTestCase" << std::endl;
+}
+
+void DistributedRadarTest::TearDown()
+{
+    DTEST_LOG << "DistributedRadarTest::TearDown" << std::endl;
+}
+
+void DistributedRadarTest::SetUp()
+{
+    DTEST_LOG << "DistributedRadarTest::SetUp" << std::endl;
+}
+
+/**
+ * @tc.name: RegisterSoftbusCallbackRes_001
+ * @tc.desc: check RegisterSoftbusCallbackRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, RegisterSoftbusCallbackRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().RegisterSoftbusCallbackRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: RegisterSoftbusCallbackRes_002
+ * @tc.desc: check RegisterSoftbusCallbackRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, RegisterSoftbusCallbackRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().RegisterSoftbusCallbackRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest RegisterSoftbusCallbackRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: RegisterFocusedRes_001
+ * @tc.desc: check RegisterFocusedRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, RegisterFocusedRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().RegisterFocusedRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: RegisterFocusedRes_002
+ * @tc.desc: check RegisterFocusedRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, RegisterFocusedRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().RegisterFocusedRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest RegisterFocusedRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: DmsFocused_001
+ * @tc.desc: check DmsFocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, DmsFocused_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest DmsFocused_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().DmsFocused(FUNC, NORMAL);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest DmsFocused_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: NormalFocusedSendEventRes_001
+ * @tc.desc: check NormalFocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NormalFocusedSendEventRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NormalFocusedSendEventRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: NormalFocusedSendEventRes_002
+ * @tc.desc: check NormalFocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NormalFocusedSendEventRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NormalFocusedSendEventRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NormalFocusedSendEventRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: SetFocusedState_001
+ * @tc.desc: check SetFocusedState
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, SetFocusedState_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest SetFocusedState_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().SetFocusedState(FUNC);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest SetFocusedState_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateFocusedGetAccessTokenIdRes_001
+ * @tc.desc: check ChangeStateFocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateFocusedGetAccessTokenIdRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateFocusedGetAccessTokenIdRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateFocusedGetAccessTokenIdRes_002
+ * @tc.desc: check ChangeStateFocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateFocusedGetAccessTokenIdRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateFocusedGetAccessTokenIdRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedGetAccessTokenIdRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateFocusedSendEventRes_001
+ * @tc.desc: check ChangeStateFocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateFocusedSendEventRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateFocusedSendEventRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateFocusedSendEventRes_002
+ * @tc.desc: check ChangeStateFocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateFocusedSendEventRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateFocusedSendEventRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateFocusedSendEventRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: DmsUnfocused_001
+ * @tc.desc: check DmsUnfocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, DmsUnfocused_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest DmsUnfocused_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().DmsUnfocused(FUNC);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest DmsUnfocused_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: NormalUnfocusedGetAccessTokenIdRes_001
+ * @tc.desc: check NormalUnfocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NormalUnfocusedGetAccessTokenIdRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NormalUnfocusedGetAccessTokenIdRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: NormalUnfocusedGetAccessTokenIdRes_002
+ * @tc.desc: check NormalUnfocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NormalUnfocusedGetAccessTokenIdRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NormalUnfocusedGetAccessTokenIdRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedGetAccessTokenIdRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: NormalUnfocusedSendEventRes_001
+ * @tc.desc: check NormalUnfocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NormalUnfocusedSendEventRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NormalUnfocusedSendEventRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: NormalUnfocusedSendEventRes_002
+ * @tc.desc: check NormalUnfocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NormalUnfocusedSendEventRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NormalUnfocusedSendEventRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NormalUnfocusedSendEventRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: RecordTime_001
+ * @tc.desc: check RecordTime
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, RecordTime_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest RecordTime_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().RecordTime(FUNC);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest RecordTime_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: MultimodeUnfocusedGetAccessTokenIdRes_001
+ * @tc.desc: check MultimodeUnfocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, MultimodeUnfocusedGetAccessTokenIdRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().MultimodeUnfocusedGetAccessTokenIdRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: MultimodeUnfocusedGetAccessTokenIdRes_002
+ * @tc.desc: check MultimodeUnfocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, MultimodeUnfocusedGetAccessTokenIdRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().MultimodeUnfocusedGetAccessTokenIdRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedGetAccessTokenIdRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: MultimodeUnfocusedSendEventRes_001
+ * @tc.desc: check MultimodeUnfocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, MultimodeUnfocusedSendEventRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().MultimodeUnfocusedSendEventRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: MultimodeUnfocusedSendEventRes_002
+ * @tc.desc: check MultimodeUnfocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, MultimodeUnfocusedSendEventRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().MultimodeUnfocusedSendEventRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest MultimodeUnfocusedSendEventRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: SetUnfocusedState_001
+ * @tc.desc: check SetUnfocusedState
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, SetUnfocusedState_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest SetUnfocusedState_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().SetUnfocusedState(FUNC);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest SetUnfocusedState_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateUnfocusedGetAccessTokenIdRes_001
+ * @tc.desc: check ChangeStateUnfocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedGetAccessTokenIdRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedGetAccessTokenIdRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateUnfocusedGetAccessTokenIdRes_002
+ * @tc.desc: check ChangeStateUnfocusedGetAccessTokenIdRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedGetAccessTokenIdRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedGetAccessTokenIdRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedGetAccessTokenIdRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateUnfocusedSendEventRes_001
+ * @tc.desc: check ChangeStateUnfocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedSendEventRes_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedSendEventRes(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ChangeStateUnfocusedSendEventRes_002
+ * @tc.desc: check ChangeStateUnfocusedSendEventRes
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ChangeStateUnfocusedSendEventRes_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ChangeStateUnfocusedSendEventRes(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ChangeStateUnfocusedSendEventRes_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: RecvFocused_001
+ * @tc.desc: check RecvFocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, RecvFocused_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest RecvFocused_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().RecvFocused(FUNC);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest RecvFocused_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: FocusedGetBundleName_001
+ * @tc.desc: check FocusedGetBundleName
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, FocusedGetBundleName_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().FocusedGetBundleName(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: FocusedGetBundleName_002
+ * @tc.desc: check FocusedGetBundleName
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, FocusedGetBundleName_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().FocusedGetBundleName(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest FocusedGetBundleName_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: NotifyDockFocused_001
+ * @tc.desc: check NotifyDockFocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NotifyDockFocused_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NotifyDockFocused_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NotifyDockFocused(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NotifyDockFocused_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: NotifyDockFocused_002
+ * @tc.desc: check NotifyDockFocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NotifyDockFocused_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NotifyDockFocused_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NotifyDockFocused(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NotifyDockFocused_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: RecvUnfocused_001
+ * @tc.desc: check RecvUnfocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, RecvUnfocused_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest RecvUnfocused_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().RecvUnfocused(FUNC);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest RecvUnfocused_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: UnfocusedGetBundleName_001
+ * @tc.desc: check UnfocusedGetBundleName
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, UnfocusedGetBundleName_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().UnfocusedGetBundleName(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: UnfocusedGetBundleName_002
+ * @tc.desc: check UnfocusedGetBundleName
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, UnfocusedGetBundleName_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().UnfocusedGetBundleName(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest UnfocusedGetBundleName_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: NotifyDockUnfocused_001
+ * @tc.desc: check NotifyDockUnfocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NotifyDockUnfocused_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NotifyDockUnfocused(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: NotifyDockUnfocused_002
+ * @tc.desc: check NotifyDockUnfocused
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, NotifyDockUnfocused_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().NotifyDockUnfocused(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest NotifyDockUnfocused_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: ClickIconDmsContinue_001
+ * @tc.desc: check ClickIconDmsContinue
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ClickIconDmsContinue_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ClickIconDmsContinue(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ClickIconDmsContinue_002
+ * @tc.desc: check ClickIconDmsContinue
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ClickIconDmsContinue_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ClickIconDmsContinue(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsContinue_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: ClickIconDmsStartAbility_001
+ * @tc.desc: check ClickIconDmsStartAbility
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ClickIconDmsStartAbility_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ClickIconDmsStartAbility(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ClickIconDmsStartAbility_002
+ * @tc.desc: check ClickIconDmsStartAbility
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ClickIconDmsStartAbility_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ClickIconDmsStartAbility(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsStartAbility_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: ClickIconDmsRecvOver_001
+ * @tc.desc: check ClickIconDmsRecvOver
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ClickIconDmsRecvOver_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ClickIconDmsRecvOver(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: ClickIconDmsRecvOver_002
+ * @tc.desc: check ClickIconDmsRecvOver
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, ClickIconDmsRecvOver_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().ClickIconDmsRecvOver(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest ClickIconDmsRecvOver_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: SaveDataDmsContinue_001
+ * @tc.desc: check SaveDataDmsContinue
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, SaveDataDmsContinue_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().SaveDataDmsContinue(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: SaveDataDmsContinue_002
+ * @tc.desc: check SaveDataDmsContinue
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, SaveDataDmsContinue_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().SaveDataDmsContinue(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsContinue_002 end" << std::endl;
+}
+
+/**
+ * @tc.name: SaveDataDmsRemoteWant_001
+ * @tc.desc: check SaveDataDmsRemoteWant
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, SaveDataDmsRemoteWant_001, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_001 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().SaveDataDmsRemoteWant(FUNC, ERR_OK);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_001 end" << std::endl;
+}
+
+/**
+ * @tc.name: SaveDataDmsRemoteWant_002
+ * @tc.desc: check SaveDataDmsRemoteWant
+ * @tc.type: FUNC
+ */
+HWTEST_F(DistributedRadarTest, SaveDataDmsRemoteWant_002, TestSize.Level3)
+{
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_002 begin" << std::endl;
+    bool ret = DmsRadar::GetInstance().SaveDataDmsRemoteWant(FUNC, ERR_NO);
+    EXPECT_EQ(ret, true);
+    DTEST_LOG << "DistributedRadarTest SaveDataDmsRemoteWant_002 end" << std::endl;
+}
+}
+}
--- a/services/dtbschedmgr/test/unittest/distributed_radar_test.h
+++ b/services/dtbschedmgr/test/unittest/distributed_radar_test.h
@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DISTRIBUTED_RADAR_TEST_H
+#define DISTRIBUTED_RADAR_TEST_H
+
+#include "gtest/gtest.h"
+#include "test_log.h"
+
+#include "distributed_radar.h"
+
+namespace OHOS {
+namespace DistributedSchedule {
+constexpr int32_t ERR_NO = 1;
+
+class DistributedRadarTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+};
+} // namespace DistributedSchedule
+} // namespace OHOS
+#endif // DISTRIBUTED_RADAR_TEST_H