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 DmCrypto::dmCrypto = cryptoMock_;
47 }
48
TearDownTestCase()49 void DmDeviceStateManagerTestTwo::TearDownTestCase()
50 {
51 DmSoftbusConnector::dmSoftbusConnector = nullptr;
52 softbusConnectorMock_ = nullptr;
53 DmCrypto::dmCrypto = nullptr;
54 }
55 namespace {
56 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
57 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
58 std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
59 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
60 std::shared_ptr<DmDeviceStateManager> dmDeviceStateManager =
61 std::make_shared<DmDeviceStateManager>(softbusConnector, listener_, hiChainConnector_, hiChainAuthConnector);
62
63 HWTEST_F(DmDeviceStateManagerTestTwo, RegisterSoftbusStateCallback_001, testing::ext::TestSize.Level0)
64 {
65 auto softbusConnector = dmDeviceStateManager->softbusConnector_;
66 dmDeviceStateManager->softbusConnector_ = nullptr;
67 int32_t ret = dmDeviceStateManager->RegisterSoftbusStateCallback();
68 EXPECT_EQ(ret, DM_OK);
69 dmDeviceStateManager->softbusConnector_ = softbusConnector;
70 }
71
72 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOfflineDeviceInfo_002, testing::ext::TestSize.Level0)
73 {
74 DmDeviceInfo info = {
75 .deviceId = "123",
76 .deviceName = "asda",
77 .deviceTypeId = 1,
78 };
79 dmDeviceStateManager->remoteDeviceInfos_["123"] = info;
80 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
81 dmDeviceStateManager->DeleteOfflineDeviceInfo(info);
82 for (auto iter: dmDeviceStateManager->remoteDeviceInfos_) {
83 if (iter.second.deviceId == info.deviceId) {
84 EXPECT_EQ(dmDeviceStateManager->remoteDeviceInfos_.count(iter.first), 0);
85 break;
86 }
87 }
88 }
89
90 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOfflineDeviceInfo_003, testing::ext::TestSize.Level0)
91 {
92 DmDeviceInfo info = {
93 .deviceId = "123",
94 .deviceName = "asda",
95 .deviceTypeId = 1,
96 };
97 dmDeviceStateManager->remoteDeviceInfos_["123"] = info;
98 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
99 strcpy_s(info.deviceId, DM_MAX_DEVICE_ID_LEN, "456");
100 dmDeviceStateManager->DeleteOfflineDeviceInfo(info);
101 for (auto iter: dmDeviceStateManager->remoteDeviceInfos_) {
102 if (iter.second.deviceId == info.deviceId) {
103 EXPECT_EQ(dmDeviceStateManager->remoteDeviceInfos_.count(iter.first), 0);
104 break;
105 }
106 }
107 }
108
109 HWTEST_F(DmDeviceStateManagerTestTwo, OnDeviceOffline_002, testing::ext::TestSize.Level0)
110 {
111 std::string deviceId = "123";
112 DmDeviceInfo info = {
113 .deviceId = "123",
114 .deviceName = "asda",
115 .deviceTypeId = 1,
116 };
117 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
118 dmDeviceStateManager->OnDeviceOffline(deviceId);
119 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
120 dmDeviceStateManager->stateDeviceInfos_.clear();
121 }
122
123 HWTEST_F(DmDeviceStateManagerTestTwo, HandleDeviceStatusChange_001, testing::ext::TestSize.Level0)
124 {
125 DmDeviceInfo info = {
126 .deviceId = "123",
127 .deviceName = "asda",
128 .deviceTypeId = 1,
129 };
130 std::vector<ProcessInfo> processInfoVec;
131 auto softbusConnector = dmDeviceStateManager->softbusConnector_;
132 dmDeviceStateManager->softbusConnector_ = nullptr;
133 dmDeviceStateManager->HandleDeviceStatusChange(DmDeviceState::DEVICE_STATE_OFFLINE, info, processInfoVec);
134 dmDeviceStateManager->softbusConnector_ = softbusConnector;
135 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_FAILED));
136 dmDeviceStateManager->HandleDeviceStatusChange(DmDeviceState::DEVICE_STATE_OFFLINE, info, processInfoVec);
137 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
138 }
139
140 HWTEST_F(DmDeviceStateManagerTestTwo, ProcessDeviceStateChange_001, testing::ext::TestSize.Level0)
141 {
142 ProcessInfo info;
143 DmDeviceInfo devInfo;
144 std::vector<ProcessInfo> processInfoVec;
145 processInfoVec.push_back(info);
146 dmDeviceStateManager->ProcessDeviceStateChange(DmDeviceState::DEVICE_STATE_OFFLINE, devInfo, processInfoVec);
147 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
148 }
149
150 HWTEST_F(DmDeviceStateManagerTestTwo, OnDeviceOnline_001, testing::ext::TestSize.Level0)
151 {
152 DmDeviceInfo info = {
153 .deviceId = "123",
154 .deviceName = "asda",
155 .deviceTypeId = 1,
156 };
157 std::vector<ProcessInfo> processInfoVec;
158 EXPECT_CALL(*softbusConnectorMock_, GetDeviceInfoByDeviceId("123")).WillOnce(Return(info));
159 EXPECT_CALL(*softbusConnectorMock_, GetProcessInfo()).WillOnce(Return(processInfoVec));
160 dmDeviceStateManager->OnDeviceOnline("123", 0);
161 EXPECT_CALL(*softbusConnectorMock_, GetDeviceInfoByDeviceId("123")).WillOnce(Return(info));
162 EXPECT_CALL(*softbusConnectorMock_, GetProcessInfo()).WillOnce(Return(processInfoVec));
163 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
164 dmDeviceStateManager->OnDeviceOnline("123", 0);
165 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
166 dmDeviceStateManager->stateDeviceInfos_.clear();
167 }
168
169 HWTEST_F(DmDeviceStateManagerTestTwo, OnDbReady_001, testing::ext::TestSize.Level0)
170 {
171 std::string pkgName;
172 std::string deviceId;
173 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
174
175 pkgName = "123";
176 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
177
178 deviceId = "123";
179 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
180
181 DmDeviceInfo deviceInfo = {
182 .deviceId = "123",
183 .deviceName = "asda",
184 .deviceTypeId = 1,
185 };
186 dmDeviceStateManager->remoteDeviceInfos_["123"] = deviceInfo;
187 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
188 EXPECT_NE(dmDeviceStateManager->listener_, nullptr);
189 auto listener = dmDeviceStateManager->listener_;
190 dmDeviceStateManager->listener_ = nullptr;
191 dmDeviceStateManager->OnDbReady(pkgName, deviceId);
192 dmDeviceStateManager->listener_ = listener;
193 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
194 }
195
196 HWTEST_F(DmDeviceStateManagerTestTwo, RegisterOffLineTimer_002, testing::ext::TestSize.Level0)
197 {
198 DmDeviceInfo info = {
199 .deviceId = "123",
200 .deviceName = "asda",
201 .deviceTypeId = 1,
202 };
203 StateTimerInfo stateTimerInfo = {
204 .isStart = true,
205 };
206 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
207 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
208 EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).WillOnce(Return(ERR_DM_FAILED));
209 dmDeviceStateManager->RegisterOffLineTimer(info);
210 EXPECT_EQ(dmDeviceStateManager->stateTimerInfoMap_["123"].isStart, true);
211 dmDeviceStateManager->stateTimerInfoMap_.clear();
212 }
213
214 HWTEST_F(DmDeviceStateManagerTestTwo, RegisterOffLineTimer_003, testing::ext::TestSize.Level0)
215 {
216 DmDeviceInfo info = {
217 .deviceId = "123",
218 .deviceName = "asda",
219 .deviceTypeId = 1,
220 };
221 StateTimerInfo stateTimerInfo = {
222 .isStart = true,
223 };
224 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
225 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
__anon10c2fadd0202(unsigned char* udidHash) 226 EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).WillOnce(DoAll(WithArgs<1>(Invoke([](unsigned char* udidHash) {
227 memcpy_s(udidHash, DM_MAX_DEVICE_ID_LEN, "123", 3);
228 })), Return(DM_OK)));
229 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
230 dmDeviceStateManager->RegisterOffLineTimer(info);
231 EXPECT_EQ(dmDeviceStateManager->stateTimerInfoMap_["123"].isStart, false);
232 dmDeviceStateManager->stateTimerInfoMap_.clear();
233 }
234
235 HWTEST_F(DmDeviceStateManagerTestTwo, RegisterOffLineTimer_004, testing::ext::TestSize.Level0)
236 {
237 DmDeviceInfo info = {
238 .deviceId = "123",
239 .deviceName = "asda",
240 .deviceTypeId = 1,
241 };
242 StateTimerInfo stateTimerInfo;
243 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
244 dmDeviceStateManager->udidhash2udidMap_["123"] = "test";
245 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
__anon10c2fadd0302(unsigned char* udidHash) 246 EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).WillOnce(DoAll(WithArgs<1>(Invoke([](unsigned char* udidHash) {
247 memcpy_s(udidHash, DM_MAX_DEVICE_ID_LEN, "123", 3);
248 })), Return(DM_OK)));
249 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
250 dmDeviceStateManager->RegisterOffLineTimer(info);
251 EXPECT_NE(dmDeviceStateManager->udidhash2udidMap_["123"], "test");
252 dmDeviceStateManager->stateTimerInfoMap_.clear();
253 dmDeviceStateManager->udidhash2udidMap_.clear();
254 }
255
256 HWTEST_F(DmDeviceStateManagerTestTwo, StartOffLineTimer_001, testing::ext::TestSize.Level0)
257 {
258 DmDeviceInfo deviceInfo;
259 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
260 dmDeviceStateManager->StartOffLineTimer(deviceInfo);
261 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
262 }
263
264 HWTEST_F(DmDeviceStateManagerTestTwo, StartOffLineTimer_002, testing::ext::TestSize.Level0)
265 {
266 DmDeviceInfo info = {
267 .deviceId = "123",
268 .deviceName = "asda",
269 .deviceTypeId = 1,
270 .networkId = "aabbcc",
271 };
272 StateTimerInfo stateTimerInfo = {
273 .timerName = "123",
274 .networkId = "aabbcc",
275 .isStart = false,
276 };
277 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
278 dmDeviceStateManager->StartOffLineTimer(info);
279 EXPECT_EQ(dmDeviceStateManager->stateTimerInfoMap_["123"].isStart, true);
280 dmDeviceStateManager->stateTimerInfoMap_.clear();
281 dmDeviceStateManager->udidhash2udidMap_.clear();
282 }
283
284 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOffLineTimer_001, testing::ext::TestSize.Level0)
285 {
286 StateTimerInfo stateTimerInfo;
287 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
288 dmDeviceStateManager->timer_ = nullptr;
289 dmDeviceStateManager->DeleteOffLineTimer("123");
290 EXPECT_NE(dmDeviceStateManager->stateTimerInfoMap_.size(), 0);
291 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
292 dmDeviceStateManager->DeleteOffLineTimer("");
293 EXPECT_NE(dmDeviceStateManager->stateTimerInfoMap_.size(), 0);
294 dmDeviceStateManager->stateTimerInfoMap_.clear();
295 }
296
297 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOffLineTimer_002, testing::ext::TestSize.Level0)
298 {
299 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
300 DmDeviceInfo info = {
301 .deviceId = "123",
302 .deviceName = "asda",
303 .deviceTypeId = 1,
304 };
305 StateTimerInfo stateTimerInfo;
306 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
307 dmDeviceStateManager->DeleteOffLineTimer("deviceInfo");
308 EXPECT_NE(dmDeviceStateManager->stateTimerInfoMap_.size(), 0);
309 dmDeviceStateManager->DeleteOffLineTimer("123");
310 EXPECT_EQ(dmDeviceStateManager->stateTimerInfoMap_.size(), 0);
311 dmDeviceStateManager->stateTimerInfoMap_.clear();
312 }
313
314 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteOffLineTimer_003, testing::ext::TestSize.Level0)
315 {
316 dmDeviceStateManager->timer_ = std::make_shared<DmTimer>();
317 DmDeviceInfo info = {
318 .deviceId = "123",
319 .deviceName = "asda",
320 .deviceTypeId = 1,
321 };
322 StateTimerInfo stateTimerInfo;
323 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
324 dmDeviceStateManager->udidhash2udidMap_["deviceInfo"] = "test";
325 dmDeviceStateManager->DeleteOffLineTimer("123");
326 EXPECT_NE(dmDeviceStateManager->udidhash2udidMap_.size(), 0);
327
328 dmDeviceStateManager->udidhash2udidMap_["123"] = "test";
329 dmDeviceStateManager->DeleteOffLineTimer("123");
330 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
331 dmDeviceStateManager->stateTimerInfoMap_.clear();
332 dmDeviceStateManager->udidhash2udidMap_.clear();
333 }
334
335 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteTimeOutGroup_001, testing::ext::TestSize.Level0)
336 {
337 DmDeviceInfo info = {
338 .deviceId = "123",
339 .deviceName = "asda",
340 .deviceTypeId = 1,
341 };
342 StateTimerInfo stateTimerInfo;
343 dmDeviceStateManager->stateTimerInfoMap_["test"] = stateTimerInfo;
344 dmDeviceStateManager->DeleteTimeOutGroup("123");
345 stateTimerInfo.timerName = "123";
346 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
347 auto hiChainConnector = dmDeviceStateManager->hiChainConnector_;
348 dmDeviceStateManager->hiChainConnector_ = nullptr;
349 dmDeviceStateManager->DeleteTimeOutGroup("123");
350 dmDeviceStateManager->hiChainConnector_ = hiChainConnector;
351 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
352 }
353
354 HWTEST_F(DmDeviceStateManagerTestTwo, DeleteTimeOutGroup_002, testing::ext::TestSize.Level0)
355 {
356 DmDeviceInfo info = {
357 .deviceId = "123",
358 .deviceName = "asda",
359 .deviceTypeId = 1,
360 };
361 StateTimerInfo stateTimerInfo;
362 stateTimerInfo.timerName = "123";
363 dmDeviceStateManager->stateTimerInfoMap_["123"] = stateTimerInfo;
364 dmDeviceStateManager->DeleteTimeOutGroup("123");
365 dmDeviceStateManager->udidhash2udidMap_["123"] = "test";
366 dmDeviceStateManager->DeleteTimeOutGroup("123");
367 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
368 }
369
370 HWTEST_F(DmDeviceStateManagerTestTwo, RunTask_001, testing::ext::TestSize.Level0)
371 {
372 std::shared_ptr<NotifyEvent> task = std::make_shared<NotifyEvent>(1, "");
373 dmDeviceStateManager->RunTask(task);
374 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
375 }
376
377 HWTEST_F(DmDeviceStateManagerTestTwo, GetAuthForm_001, testing::ext::TestSize.Level0)
378 {
379 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
380 dmDeviceStateManager->GetAuthForm("task");
381 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
382 }
383
384 HWTEST_F(DmDeviceStateManagerTestTwo, ChangeDeviceInfo_001, testing::ext::TestSize.Level0)
385 {
386 std::string deviceId = "123";
387 DmDeviceInfo info = {
388 .deviceId = "123",
389 .deviceName = "asda",
390 .deviceTypeId = 1,
391 };
392 dmDeviceStateManager->stateDeviceInfos_.clear();
393 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
394 dmDeviceStateManager->ChangeDeviceInfo(info);
395 strcpy_s(info.deviceId, DM_MAX_DEVICE_ID_LEN, "456");
396 dmDeviceStateManager->ChangeDeviceInfo(info);
397 EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
398 }
399
400 HWTEST_F(DmDeviceStateManagerTestTwo, CheckIsOnline_001, testing::ext::TestSize.Level0)
401 {
402 DmDeviceInfo info = {
403 .deviceId = "123",
404 .deviceName = "asda",
405 .deviceTypeId = 1,
406 };
407 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
408 bool ret = dmDeviceStateManager->CheckIsOnline("123");
409 EXPECT_EQ(ret, true);
410 }
411
412 HWTEST_F(DmDeviceStateManagerTestTwo, GetUdidByNetWorkId_001, testing::ext::TestSize.Level0)
413 {
414 DmDeviceInfo info = {
415 .deviceId = "123",
416 .deviceName = "asda",
417 .deviceTypeId = 1,
418 .networkId = "123"
419 };
420 dmDeviceStateManager->stateDeviceInfos_["123"] = info;
421 std::string ret = dmDeviceStateManager->GetUdidByNetWorkId("123");
422 EXPECT_EQ(ret, "123");
423 ret = dmDeviceStateManager->GetUdidByNetWorkId("test");
424 EXPECT_EQ(ret, "");
425 }
426 } // namespace
427 } // namespace DistributedHardware
428 } // namespace OHOS
429