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 #include "UTTest_dm_device_state_manager_two.h"
17
18 #include <iostream>
19
20 #include "dm_log.h"
21 #include "dm_constants.h"
22 #include "dm_adapter_manager.h"
23 #include "ipc_notify_device_state_req.h"
24 #include "ipc_notify_auth_result_req.h"
25 #include "dm_device_state_manager.h"
26 #include "ipc_notify_device_found_req.h"
27 #include "ipc_notify_discover_result_req.h"
28 #include "hichain_connector.h"
29 #include "device_manager_service_listener.h"
30
31 using namespace testing;
32 using namespace testing::ext;
33 namespace OHOS {
34 namespace DistributedHardware {
SetUp()35 void DmDeviceStateManagerTestTwo::SetUp()
36 {
37 }
38
TearDown()39 void DmDeviceStateManagerTestTwo::TearDown()
40 {
41 }
42
SetUpTestCase()43 void DmDeviceStateManagerTestTwo::SetUpTestCase()
44 {
45 DmSoftbusConnector::dmSoftbusConnector = softbusConnectorMock_;
46 }
47
TearDownTestCase()48 void DmDeviceStateManagerTestTwo::TearDownTestCase()
49 {
50 DmSoftbusConnector::dmSoftbusConnector = nullptr;
51 softbusConnectorMock_ = nullptr;
52 }
53 namespace {
54 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
55 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
56 std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
57 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
58 std::shared_ptr<DmDeviceStateManager> dmDeviceStateManager =
59 std::make_shared<DmDeviceStateManager>(softbusConnector, listener_, hiChainConnector_, hiChainAuthConnector);
60
61 HWTEST_F(DmDeviceStateManagerTestTwo, RegisterSoftbusStateCallback_001, testing::ext::TestSize.Level0)
62 {
63 auto softbusConnector = dmDeviceStateManager->softbusConnector_;
64 dmDeviceStateManager->softbusConnector_ = nullptr;
65 int32_t ret = dmDeviceStateManager->RegisterSoftbusStateCallback();
66 EXPECT_EQ(ret, DM_OK);
67 dmDeviceStateManager->softbusConnector_ = softbusConnector;
68 }
69
70 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOfflineDeviceInfo_002, testing::ext::TestSize.Level0)
71 {
72 DmDeviceInfo info = {
73 .deviceId = "123",
74 .deviceName = "asda",
75 .deviceTypeId = 1,
76 };
77 dmDeviceStateManager->remoteDeviceInfos_["123"] = info;
78 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
79 dmDeviceStateManager->DeleteOfflineDeviceInfo(info);
80 for (auto iter: dmDeviceStateManager->remoteDeviceInfos_) {
81 if (iter.second.deviceId == info.deviceId) {
82 EXPECT_EQ(dmDeviceStateManager->remoteDeviceInfos_.count(iter.first), 0);
83 break;
84 }
85 }
86 }
87
88 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOfflineDeviceInfo_003, testing::ext::TestSize.Level0)
89 {
90 DmDeviceInfo info = {
91 .deviceId = "123",
92 .deviceName = "asda",
93 .deviceTypeId = 1,
94 };
95 dmDeviceStateManager->remoteDeviceInfos_["123"] = info;
96 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
97 strcpy_s(info.deviceId, DM_MAX_DEVICE_ID_LEN, "456");
98 dmDeviceStateManager->DeleteOfflineDeviceInfo(info);
99 for (auto iter: dmDeviceStateManager->remoteDeviceInfos_) {
100 if (iter.second.deviceId == info.deviceId) {
101 EXPECT_EQ(dmDeviceStateManager->remoteDeviceInfos_.count(iter.first), 0);
102 break;
103 }
104 }
105 }
106
107 HWTEST_F(DmDeviceStateManagerTestTwo, OnDeviceOffline_002, testing::ext::TestSize.Level0)
108 {
109 std::string deviceId = "123";
110 DmDeviceInfo info = {
111 .deviceId = "123",
112 .deviceName = "asda",
113 .deviceTypeId = 1,
114 };
115 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
116 dmDeviceStateManager->OnDeviceOffline(deviceId);
117 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
118 }
119
120 HWTEST_F(DmDeviceStateManagerTestTwo, HandleDeviceStatusChange_001, testing::ext::TestSize.Level0)
121 {
122 DmDeviceInfo info = {
123 .deviceId = "123",
124 .deviceName = "asda",
125 .deviceTypeId = 1,
126 };
127 auto softbusConnector = dmDeviceStateManager->softbusConnector_;
128 dmDeviceStateManager->softbusConnector_ = nullptr;
129 dmDeviceStateManager->HandleDeviceStatusChange(DmDeviceState::DEVICE_STATE_OFFLINE, info);
130 dmDeviceStateManager->softbusConnector_ = softbusConnector;
131 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_FAILED));
132 dmDeviceStateManager->HandleDeviceStatusChange(DmDeviceState::DEVICE_STATE_OFFLINE, info);
133 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
134 }
135
136 HWTEST_F(DmDeviceStateManagerTestTwo, ProcessDeviceStateChange_001, testing::ext::TestSize.Level0)
137 {
138 ProcessInfo info;
139 DmDeviceInfo devInfo;
140 std::vector<ProcessInfo> processInfoVec;
141 processInfoVec.push_back(info);
142 EXPECT_CALL(*softbusConnectorMock_, GetProcessInfo()).WillOnce(Return(processInfoVec));
143 dmDeviceStateManager->ProcessDeviceStateChange(DmDeviceState::DEVICE_STATE_OFFLINE, devInfo);
144 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
145 }
146
147 HWTEST_F(DmDeviceStateManagerTestTwo, OnDeviceOnline_001, testing::ext::TestSize.Level0)
148 {
149 DmDeviceInfo info = {
150 .deviceId = "123",
151 .deviceName = "asda",
152 .deviceTypeId = 1,
153 };
154 std::vector<ProcessInfo> processInfoVec;
155 EXPECT_CALL(*softbusConnectorMock_, GetDeviceInfoByDeviceId("123")).WillOnce(Return(info));
156 EXPECT_CALL(*softbusConnectorMock_, GetProcessInfo()).WillOnce(Return(processInfoVec));
157 dmDeviceStateManager->OnDeviceOnline("123", 0);
158 EXPECT_CALL(*softbusConnectorMock_, GetDeviceInfoByDeviceId("123")).WillOnce(Return(info));
159 EXPECT_CALL(*softbusConnectorMock_, GetProcessInfo()).WillOnce(Return(processInfoVec));
160 dmDeviceStateManager->OnDeviceOnline("123", 0);
161 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
162 }
163
164 HWTEST_F(DmDeviceStateManagerTestTwo, OnDbReady_001, testing::ext::TestSize.Level0)
165 {
166 std::string pkgName = "123";
167 std::string deviceId = "123";
168 DmDeviceInfo info;
169 strcpy_s(info.deviceId, DM_MAX_DEVICE_ID_LEN, "123");
170 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
171 DmDeviceInfo deviceInfo = {
172 .deviceId = "123",
173 .deviceName = "asda",
174 .deviceTypeId = 1,
175 };
176 dmDeviceStateManager->remoteDeviceInfos_["123"] = deviceInfo;
177 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
178 EXPECT_NE(dmDeviceStateManager->listener_, nullptr);
179 auto listener = dmDeviceStateManager->listener_;
180 dmDeviceStateManager->listener_ = nullptr;
181 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
182 dmDeviceStateManager->listener_ = listener;
183 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
184 }
185
186 HWTEST_F(DmDeviceStateManagerTestTwo, RegisterOffLineTimer_001, testing::ext::TestSize.Level0)
187 {
188 DmDeviceInfo info = {
189 .deviceId = "123",
190 .deviceName = "asda",
191 .deviceTypeId = 1,
192 };
193 StateTimerInfo stateTimerInfo;
194 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
195 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
196 dmDeviceStateManager->RegisterOffLineTimer(info);
197 }
198
199 HWTEST_F(DmDeviceStateManagerTestTwo, StartOffLineTimer_001, testing::ext::TestSize.Level0)
200 {
201 DmDeviceInfo deviceInfo;
202 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
203 dmDeviceStateManager->StartOffLineTimer(deviceInfo);
204 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
205 }
206
207 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOffLineTimer_001, testing::ext::TestSize.Level0)
208 {
209 dmDeviceStateManager->timer_ = nullptr;
210 dmDeviceStateManager->DeleteOffLineTimer("123");
211 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
212 dmDeviceStateManager->DeleteOffLineTimer("");
213 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
214 }
215
216 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOffLineTimer_002, testing::ext::TestSize.Level0)
217 {
218 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
219 DmDeviceInfo info = {
220 .deviceId = "123",
221 .deviceName = "asda",
222 .deviceTypeId = 1,
223 };
224 StateTimerInfo stateTimerInfo;
225 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
226 dmDeviceStateManager->DeleteOffLineTimer("deviceInfo");
227 dmDeviceStateManager->DeleteOffLineTimer("123");
228 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
229 }
230
231 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOffLineTimer_003, testing::ext::TestSize.Level0)
232 {
233 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
234 DmDeviceInfo info = {
235 .deviceId = "123",
236 .deviceName = "asda",
237 .deviceTypeId = 1,
238 };
239 StateTimerInfo stateTimerInfo;
240 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
241 dmDeviceStateManager->DeleteOffLineTimer("123");
242 dmDeviceStateManager->udidhash2udidMap_["123"] = "test";
243 dmDeviceStateManager->DeleteOffLineTimer("123");
244 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
245 }
246
247 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOffLineTimer_004, testing::ext::TestSize.Level0)
248 {
249 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
250 DmDeviceInfo info = {
251 .deviceId = "123",
252 .deviceName = "asda",
253 .deviceTypeId = 1,
254 };
255 StateTimerInfo stateTimerInfo;
256 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
257 dmDeviceStateManager->udidhash2udidMap_["123"] = "test";
258 dmDeviceStateManager->DeleteOffLineTimer("123");
259 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
260 }
261
262 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteTimeOutGroup_001, testing::ext::TestSize.Level0)
263 {
264 DmDeviceInfo info = {
265 .deviceId = "123",
266 .deviceName = "asda",
267 .deviceTypeId = 1,
268 };
269 StateTimerInfo stateTimerInfo;
270 dmDeviceStateManager->stateTimerInfoMap_["test"] = stateTimerInfo;
271 dmDeviceStateManager->DeleteTimeOutGroup("123");
272 stateTimerInfo.timerName = "123";
273 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
274 auto hiChainConnector = dmDeviceStateManager->hiChainConnector_;
275 dmDeviceStateManager->hiChainConnector_ = nullptr;
276 dmDeviceStateManager->DeleteTimeOutGroup("123");
277 dmDeviceStateManager->hiChainConnector_ = hiChainConnector;
278 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
279 }
280
281 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteTimeOutGroup_002, testing::ext::TestSize.Level0)
282 {
283 DmDeviceInfo info = {
284 .deviceId = "123",
285 .deviceName = "asda",
286 .deviceTypeId = 1,
287 };
288 StateTimerInfo stateTimerInfo;
289 stateTimerInfo.timerName = "123";
290 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
291 dmDeviceStateManager->DeleteTimeOutGroup("123");
292 dmDeviceStateManager->udidhash2udidMap_["123"] = "test";
293 dmDeviceStateManager->DeleteTimeOutGroup("123");
294 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
295 }
296
297 HWTEST_F(DmDeviceStateManagerTestTwo, RunTask_001, testing::ext::TestSize.Level0)
298 {
299 std::shared_ptr<NotifyEvent> task = std::make_shared<NotifyEvent>(1, "");
300 dmDeviceStateManager->RunTask(task);
301 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
302 }
303
304 HWTEST_F(DmDeviceStateManagerTestTwo, GetAuthForm_001, testing::ext::TestSize.Level0)
305 {
306 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
307 dmDeviceStateManager->GetAuthForm("task");
308 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
309 }
310
311 HWTEST_F(DmDeviceStateManagerTestTwo, ChangeDeviceInfo_001, testing::ext::TestSize.Level0)
312 {
313 std::string deviceId = "123";
314 DmDeviceInfo info = {
315 .deviceId = "123",
316 .deviceName = "asda",
317 .deviceTypeId = 1,
318 };
319 dmDeviceStateManager->stateDeviceInfos_.clear();
320 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
321 dmDeviceStateManager->ChangeDeviceInfo(info);
322 strcpy_s(info.deviceId, DM_MAX_DEVICE_ID_LEN, "456");
323 dmDeviceStateManager->ChangeDeviceInfo(info);
324 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
325 }
326
327 HWTEST_F(DmDeviceStateManagerTestTwo, CheckIsOnline_001, testing::ext::TestSize.Level0)
328 {
329 DmDeviceInfo info = {
330 .deviceId = "123",
331 .deviceName = "asda",
332 .deviceTypeId = 1,
333 };
334 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
335 bool ret = dmDeviceStateManager->CheckIsOnline("123");
336 EXPECT_EQ(ret, true);
337 }
338
339 HWTEST_F(DmDeviceStateManagerTestTwo, GetUdidByNetWorkId_001, testing::ext::TestSize.Level0)
340 {
341 DmDeviceInfo info = {
342 .deviceId = "123",
343 .deviceName = "asda",
344 .deviceTypeId = 1,
345 .networkId = "123"
346 };
347 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
348 std::string ret = dmDeviceStateManager->GetUdidByNetWorkId("123");
349 EXPECT_EQ(ret, "123");
350 ret = dmDeviceStateManager->GetUdidByNetWorkId("test");
351 EXPECT_EQ(ret, "");
352 }
353 } // namespace
354 } // namespace DistributedHardware
355 } // namespace OHOS
356