1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifndef OHOS_DISTRIBUTED_ONLINE_TASK_TEST_H
17 #define OHOS_DISTRIBUTED_ONLINE_TASK_TEST_H
18
19 #include <gtest/gtest.h>
20
21 #include "device_manager.h"
22 #include "dm_device_info.h"
23
24 #include "capability_info_manager.h"
25 #include "capability_info.h"
26 #include "dh_utils_tool.h"
27 #include "dh_context.h"
28 #include "local_capability_info_manager.h"
29 #include "meta_info_manager.h"
30 #include "meta_capability_info.h"
31 #include "mock_dh_utils_tool.h"
32 #include "online_task.h"
33 #include "offline_task.h"
34 #include "task.h"
35 #include "task_board.h"
36
37 using namespace testing::ext;
38 using namespace std;
39 using namespace testing;
40
41 namespace OHOS {
42 namespace DistributedHardware {
43 namespace {
44 const std::string NETWORKID_TEST = "111111";
45 const std::string UUID_TEST = "222222";
46 const std::string UDID_TEST = "333333";
47 const std::string DHID_TEST = "audio_1";
48 const std::string DEV_NAME_TEST = "phone";
49 const DHType DH_TYPE_TEST = DHType::AUDIO;
50 const uint16_t DEV_TYPE_TEST = 14;
51 }
52
53 class OnlineTaskTest : public testing::Test {
54 public:
55 static void SetUpTestCase();
56 static void TearDownTestCase();
57 void SetUp();
58 void TearDown();
59
60 private:
61 std::shared_ptr<MockDhUtilTool> utilTool_;
62 };
63
SetUpTestCase()64 void OnlineTaskTest::SetUpTestCase()
65 {
66 }
67
TearDownTestCase()68 void OnlineTaskTest::TearDownTestCase()
69 {
70 }
71
SetUp()72 void OnlineTaskTest::SetUp()
73 {
74 auto utilTool = IDhUtilTool::GetOrCreateInstance();
75 utilTool_ = std::static_pointer_cast<MockDhUtilTool>(utilTool);
76 }
77
TearDown()78 void OnlineTaskTest::TearDown()
79 {
80 IDhUtilTool::ReleaseInstance();
81 utilTool_ = nullptr;
82 }
83
84 HWTEST_F(OnlineTaskTest, CreateEnableTask_001, TestSize.Level1)
85 {
86 OnLineTask onlineTask(NETWORKID_TEST, UUID_TEST, UDID_TEST, DHID_TEST, DH_TYPE_TEST);
87 std::string deviceId = Sha256(UUID_TEST);
88 std::string udidHash = Sha256(UDID_TEST);
89 std::string capinfoKey = deviceId + RESOURCE_SEPARATOR + DHID_TEST;
90 std::string metaInfoKey = udidHash + RESOURCE_SEPARATOR + DHID_TEST;
91 std::shared_ptr<CapabilityInfo> capPtr = nullptr;
92 std::shared_ptr<MetaCapabilityInfo> metaCapPtr = nullptr;
93 CapabilityInfoManager::GetInstance()->globalCapInfoMap_[capinfoKey] = capPtr;
94 LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[capinfoKey] = capPtr;
95 MetaInfoManager::GetInstance()->globalMetaInfoMap_[metaInfoKey] = metaCapPtr;
96 ASSERT_NO_FATAL_FAILURE(onlineTask.CreateEnableTask());
97 }
98
99 HWTEST_F(OnlineTaskTest, CreateEnableSinkTask_001, TestSize.Level1)
100 {
101 OnLineTask onlineTask(NETWORKID_TEST, UUID_TEST, UDID_TEST, DHID_TEST, DH_TYPE_TEST);
102 std::string deviceId = Sha256(UUID_TEST);
103 std::string udidHash = Sha256(UDID_TEST);
104 std::string metaInfoKey = udidHash + RESOURCE_SEPARATOR + DHID_TEST;
105 std::shared_ptr<MetaCapabilityInfo> metaCapPtr = nullptr;
106 MetaInfoManager::GetInstance()->globalMetaInfoMap_[metaInfoKey] = metaCapPtr;
107 DeviceInfo deviceInfo(NETWORKID_TEST, UUID_TEST, deviceId, UDID_TEST, udidHash, DEV_NAME_TEST, DEV_TYPE_TEST);
108 EXPECT_CALL(*utilTool_, GetLocalDeviceInfo()).WillRepeatedly(Return(deviceInfo));
109 ASSERT_NO_FATAL_FAILURE(onlineTask.CreateEnableSinkTask());
110 }
111
112 HWTEST_F(OnlineTaskTest, CreateDisableTask_001, TestSize.Level1)
113 {
114 OffLineTask offlineTask(NETWORKID_TEST, UUID_TEST, UDID_TEST, DHID_TEST, DH_TYPE_TEST);
115 DHContext::GetInstance().AddOnlineDevice(UDID_TEST, UUID_TEST, NETWORKID_TEST);
116 std::string deviceId = Sha256(UUID_TEST);
117 std::string udidHash = Sha256(UDID_TEST);
118 std::string capinfoKey = deviceId + RESOURCE_SEPARATOR + DHID_TEST;
119 std::string metaInfoKey = udidHash + RESOURCE_SEPARATOR + DHID_TEST;
120 std::shared_ptr<CapabilityInfo> capPtr = nullptr;
121 std::shared_ptr<MetaCapabilityInfo> metaCapPtr = nullptr;
122 CapabilityInfoManager::GetInstance()->globalCapInfoMap_[capinfoKey] = capPtr;
123 MetaInfoManager::GetInstance()->globalMetaInfoMap_[metaInfoKey] = metaCapPtr;
124 ASSERT_NO_FATAL_FAILURE(offlineTask.CreateDisableTask());
125 }
126
127 HWTEST_F(OnlineTaskTest, CreateDisableSinkTask_001, TestSize.Level1)
128 {
129 OffLineTask offlineTask(NETWORKID_TEST, UUID_TEST, UDID_TEST, DHID_TEST, DH_TYPE_TEST);
130 std::string deviceId = Sha256(UUID_TEST);
131 std::string udidHash = Sha256(UDID_TEST);
132 std::string metaInfoKey = udidHash + RESOURCE_SEPARATOR + DHID_TEST;
133 std::shared_ptr<MetaCapabilityInfo> metaCapPtr = nullptr;
134 MetaInfoManager::GetInstance()->globalMetaInfoMap_[metaInfoKey] = metaCapPtr;
135 DeviceInfo deviceInfo(NETWORKID_TEST, UUID_TEST, deviceId, UDID_TEST, udidHash, DEV_NAME_TEST, DEV_TYPE_TEST);
136 EXPECT_CALL(*utilTool_, GetLocalDeviceInfo()).WillRepeatedly(Return(deviceInfo));
137 ASSERT_NO_FATAL_FAILURE(offlineTask.CreateDisableSinkTask());
138 }
139
140 HWTEST_F(OnlineTaskTest, DumpAllTasks_001, TestSize.Level1)
141 {
142 std::vector<TaskDump> taskInfos;
143 std::string taskId = "task_001";
144 std::shared_ptr<Task> task = nullptr;
145 TaskBoard::GetInstance().tasks_.emplace(taskId, task);
146 TaskBoard::GetInstance().DumpAllTasks(taskInfos);
147 ASSERT_TRUE(taskInfos.empty());
148 TaskBoard::GetInstance().tasks_.clear();
149 }
150
151 HWTEST_F(OnlineTaskTest, IsAllDisableTaskFinish_001, TestSize.Level1)
152 {
153 std::string taskId = "task_001";
154 std::shared_ptr<Task> task = nullptr;
155 TaskBoard::GetInstance().tasks_.emplace(taskId, task);
156 auto ret = TaskBoard::GetInstance().IsAllDisableTaskFinish();
157 EXPECT_EQ(ret, true);
158 TaskBoard::GetInstance().tasks_.clear();
159 }
160
161 HWTEST_F(OnlineTaskTest, IsAllDisableTaskFinish_002, TestSize.Level1)
162 {
163 std::string taskId = "task_002";
164 std::shared_ptr<Task> onlineTask = std::make_shared<OnLineTask>("networkId", "uuid", "udid", "dhId", DHType::AUDIO);
165 TaskBoard::GetInstance().tasks_.emplace(taskId, onlineTask);
166 auto ret = TaskBoard::GetInstance().IsAllDisableTaskFinish();
167 EXPECT_EQ(ret, true);
168 TaskBoard::GetInstance().tasks_.clear();
169 }
170 } // namespace DistributedHardware
171 } // namespace OHOS
172 #endif