1 /*
2 * Copyright (c) 2022-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 #include "device/device_manager_agent.h"
16
17 #include <atomic>
18 #include <exception>
19 #include <memory>
20 #include <unistd.h>
21
22 #include "gtest/gtest.h"
23
24 #include "device_manager_impl_mock.h"
25 #include "mountpoint/mount_point.h"
26 #include "network/softbus/softbus_agent.h"
27
28 namespace OHOS {
29 bool g_parameterVaule = true;
30 namespace system {
GetBoolParameter(const std::string & key,bool def)31 bool GetBoolParameter(const std::string& key, bool def)
32 {
33 return g_parameterVaule;
34 }
35 }
36 }
37
38 namespace OHOS {
39 namespace Storage {
40 namespace DistributedFile {
41 namespace Test {
42 using namespace testing;
43 using namespace testing::ext;
44 using namespace std;
45
46 DistributedHardware::DmDeviceInfo deviceInfo = {
47 .deviceId = "testdevid",
48 .deviceName = "testdevname",
49 .deviceTypeId = 1,
50 .networkId = "testNetWork",
51 .extraData = R"({"OS_TYPE":10})",
52 };
53
54 const std::string NETWORKID_ONE = "45656596896323231";
55 const std::string NETWORKID_TWO = "45656596896323232";
56 const std::string NETWORKID_THREE = "45656596896323233";
57 constexpr int32_t NETWORKTYPE_WITH_WIFI = 2;
58 constexpr int32_t NETWORKTYPE_NONE_WIFI = 4;
59
60 class DeviceManagerAgentTest : public testing::Test {
61 public:
62 static void SetUpTestCase(void);
63 static void TearDownTestCase(void);
64 void SetUp();
65 void TearDown();
66 static inline shared_ptr<DeviceManagerImplMock> deviceManagerImplMock_ = nullptr;
67 };
68
SetUpTestCase(void)69 void DeviceManagerAgentTest::SetUpTestCase(void)
70 {
71 // input testsuit setup step，setup invoked before all testcases
72 deviceManagerImplMock_ = make_shared<DeviceManagerImplMock>();
73 DeviceManagerImplMock::dfsDeviceManagerImpl = deviceManagerImplMock_;
74 EXPECT_CALL(*deviceManagerImplMock_, InitDeviceManager(_, _)).WillRepeatedly(Return(0));
75 EXPECT_CALL(*deviceManagerImplMock_, RegisterDevStateCallback(_, _, _)).WillRepeatedly(Return(0));
76 EXPECT_CALL(*deviceManagerImplMock_, UnRegisterDevStateCallback(_)).WillRepeatedly(Return(0));
77 EXPECT_CALL(*deviceManagerImplMock_, UnInitDeviceManager(_)).WillRepeatedly(Return(0));
78 EXPECT_CALL(*deviceManagerImplMock_, UnInitDeviceManager(_)).WillRepeatedly(Return(0));
79 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _)).WillRepeatedly(Return(0));
80 }
81
TearDownTestCase(void)82 void DeviceManagerAgentTest::TearDownTestCase(void)
83 {
84 // input testsuit teardown step，teardown invoked after all testcases
85 DeviceManagerImplMock::dfsDeviceManagerImpl = nullptr;
86 deviceManagerImplMock_ = nullptr;
87 }
88
SetUp(void)89 void DeviceManagerAgentTest::SetUp(void)
90 {
91 // input testcase setup step，setup invoked before each testcases
92 }
93
TearDown(void)94 void DeviceManagerAgentTest::TearDown(void)
95 {
96 // input testcase teardown step，teardown invoked after each testcases
97 }
98
99 /**
100 * @tc.name: DeviceManagerAgentTest_OnDeviceOnline_0100
101 * @tc.desc: Verify the OnDeviceOnline function.
102 * @tc.type: FUNC
103 * @tc.require: SR000H0387
104 */
105 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceOnline_0100, TestSize.Level1)
106 {
107 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOnline_0100 start";
108 bool res = true;
109
110 try {
111 DeviceManagerAgent::GetInstance()->OnDeviceOnline(deviceInfo);
112 } catch (const exception &e) {
113 LOGE("Error:%{public}s", e.what());
114 res = false;
115 }
116
117 EXPECT_TRUE(res == true);
118 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOnline_0100 end";
119 }
120
121 /**
122 * @tc.name: DeviceManagerAgentTest_OnDeviceOnline_0400
123 * @tc.desc: Verify the OnDeviceOnline function.
124 * @tc.type: FUNC
125 * @tc.require: SR000H0387
126 */
127 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceOnline_0400, TestSize.Level1)
128 {
129 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOnline_0400 start";
130 bool res = true;
131
132 try {
133 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
134 auto agent1 = make_shared<SoftbusAgent>(smp);
135 (void)memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_NAME_LEN - 1,
136 NETWORKID_TWO.c_str(), NETWORKID_TWO.size());
137 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.insert({ NETWORKID_TWO, agent1 });
138 DeviceManagerAgent::GetInstance()->cidNetworkType_.insert({ NETWORKID_TWO, NETWORKTYPE_NONE_WIFI });
139 DeviceManagerAgent::GetInstance()->OnDeviceOnline(deviceInfo);
140 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.erase(NETWORKID_TWO);
141 DeviceManagerAgent::GetInstance()->cidNetworkType_.erase(NETWORKID_TWO);
142 } catch (const exception &e) {
143 GTEST_LOG_(INFO) << e.what();
144 res = false;
145 }
146
147 EXPECT_TRUE(res);
148 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOnline_0400 end";
149 }
150
151 /**
152 * @tc.name: DeviceManagerAgentTest_OnDeviceOffline_0100
153 * @tc.desc: Verify the OnDeviceOffline function.
154 * @tc.type: FUNC
155 * @tc.require: SR000H0387
156 */
157 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceOffline_0100, TestSize.Level1)
158 {
159 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOffline_0100 start";
160 bool res = true;
161
162 try {
163 DeviceManagerAgent::GetInstance()->OnDeviceOffline(deviceInfo);
164 } catch (const exception &e) {
165 LOGE("Error:%{public}s", e.what());
166 res = false;
167 }
168
169 EXPECT_TRUE(res == true);
170 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOffline_0100 end";
171 }
172
173 /**
174 * @tc.name: DeviceManagerAgentTest_OnDeviceOffline_0200
175 * @tc.desc: Verify the OnDeviceOffline function.
176 * @tc.type: FUNC
177 * @tc.require: SR000H0387
178 */
179 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceOffline_0200, TestSize.Level1)
180 {
181 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOffline_0200 start";
182 bool res = true;
183
184 try {
185 DeviceManagerAgent::GetInstance()->OnDeviceOnline(deviceInfo);
186 DeviceManagerAgent::GetInstance()->OnDeviceOffline(deviceInfo);
187 } catch (const exception &e) {
188 LOGE("Error:%{public}s", e.what());
189 res = false;
190 }
191
192 EXPECT_TRUE(res == true);
193 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOffline_0200 end";
194 }
195
196 /**
197 * @tc.name: DeviceManagerAgentTest_OnDeviceOffline_0300
198 * @tc.desc: Verify the OnDeviceOffline function.
199 * @tc.type: FUNC
200 * @tc.require: SR000H0387
201 */
202 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceOffline_0300, TestSize.Level1)
203 {
204 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOffline_0300 start";
205 bool res = true;
206
207 try {
208 EXPECT_CALL(*deviceManagerImplMock_, GetLocalDeviceInfo(_, _)).WillOnce(Return(0))
209 .WillOnce(Return(0)).WillOnce(Return(0));
210 DeviceManagerAgent::GetInstance()->InitLocalNodeInfo();
211 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
212 auto agent1 = make_shared<SoftbusAgent>(smp);
213 (void)memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_NAME_LEN - 1,
214 NETWORKID_TWO.c_str(), NETWORKID_TWO.size());
215 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.insert({ NETWORKID_TWO, agent1 });
216 DeviceManagerAgent::GetInstance()->cidNetworkType_.insert({ NETWORKID_TWO, NETWORKTYPE_NONE_WIFI });
217 DeviceManagerAgent::GetInstance()->OnDeviceOnline(deviceInfo);
218 DeviceManagerAgent::GetInstance()->OnDeviceOffline(deviceInfo);
219 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.erase(NETWORKID_TWO);
220 DeviceManagerAgent::GetInstance()->cidNetworkType_.erase(NETWORKID_TWO);
221 } catch (const exception &e) {
222 GTEST_LOG_(INFO) << e.what();
223 res = false;
224 }
225
226 EXPECT_TRUE(res == true);
227 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceOffline_0300 end";
228 }
229
230 /**
231 * @tc.name: DeviceManagerAgentTest_OnDeviceChanged_0100
232 * @tc.desc: Verify the OnDeviceChanged function.
233 * @tc.type: FUNC
234 * @tc.require: SR000H0387
235 */
236 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceChanged_0100, TestSize.Level1)
237 {
238 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0100 start";
239 bool res = true;
240
241 try {
242 DeviceManagerAgent::GetInstance()->OnDeviceChanged(deviceInfo);
243 } catch (const exception &e) {
244 LOGE("Error:%{public}s", e.what());
245 res = false;
246 }
247
248 EXPECT_TRUE(res == true);
249 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0100 end";
250 }
251
252 /**
253 * @tc.name: DeviceManagerAgentTest_OnDeviceChanged_0200
254 * @tc.desc: Verify the OnDeviceChanged function.
255 * @tc.type: FUNC
256 * @tc.require: SR000H0387
257 */
258 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceChanged_0200, TestSize.Level1)
259 {
260 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0200 start";
261 bool res = true;
262
263 try {
264 deviceInfo.networkType = -1;
265 DeviceManagerAgent::GetInstance()->OnDeviceChanged(deviceInfo);
266 deviceInfo.networkType = 1;
267 DeviceManagerAgent::GetInstance()->OnDeviceChanged(deviceInfo);
268 } catch (const exception &e) {
269 GTEST_LOG_(INFO) << e.what();
270 res = false;
271 }
272
273 EXPECT_TRUE(res);
274 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0200 end";
275 }
276
277 /**
278 * @tc.name: DeviceManagerAgentTest_OnDeviceChanged_0300
279 * @tc.desc: Verify the OnDeviceChanged function.
280 * @tc.type: FUNC
281 * @tc.require: SR000H0387
282 */
283 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceChanged_0300, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0300 start";
286 bool res = true;
287
288 try {
289 deviceInfo.networkType = NETWORKTYPE_NONE_WIFI;
290 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
291 auto agent1 = make_shared<SoftbusAgent>(smp);
292 (void)memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_NAME_LEN - 1,
293 NETWORKID_THREE.c_str(), NETWORKID_THREE.size());
294 std::vector<DmDeviceInfo> deviceList;
295 deviceList.push_back(deviceInfo);
296 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
297 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
298 auto devicePtr = DeviceManagerAgent::GetInstance();
299 devicePtr->cidNetTypeRecord_.insert({ NETWORKID_THREE, agent1 });
300 devicePtr->OnDeviceChanged(deviceInfo);
301
302 devicePtr->cidNetworkType_.insert({ NETWORKID_THREE, NETWORKTYPE_NONE_WIFI });
303 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
304 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
305 devicePtr->OnDeviceChanged(deviceInfo);
306
307 deviceInfo.networkType = NETWORKTYPE_WITH_WIFI;
308 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
309 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
310 devicePtr->OnDeviceChanged(deviceInfo);
311 devicePtr->cidNetTypeRecord_.erase(NETWORKID_THREE);
312 devicePtr->cidNetworkType_.erase(NETWORKID_THREE);
313 } catch (const exception &e) {
314 GTEST_LOG_(INFO) << e.what();
315 res = false;
316 }
317
318 EXPECT_TRUE(res);
319 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0300 end";
320 }
321
322 /**
323 * @tc.name: DeviceManagerAgentTest_OnDeviceChanged_0400
324 * @tc.desc: Verify the OnDeviceChanged function.
325 * @tc.type: FUNC
326 * @tc.require: SR000H0387
327 */
328 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceChanged_0400, TestSize.Level1)
329 {
330 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0400 start";
331 bool res = true;
332
333 try {
334 deviceInfo.networkType = NETWORKTYPE_WITH_WIFI;
335 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
336 auto agent1 = make_shared<SoftbusAgent>(smp);
337 (void)memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_NAME_LEN - 1,
338 NETWORKID_TWO.c_str(), NETWORKID_TWO.size());
339 std::vector<DmDeviceInfo> deviceList;
340 deviceList.push_back(deviceInfo);
341 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
342 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
343 auto devicePtr = DeviceManagerAgent::GetInstance();
344 devicePtr->cidNetTypeRecord_.insert({ NETWORKID_TWO, agent1 });
345 devicePtr->cidNetworkType_.insert({ NETWORKID_TWO, NETWORKTYPE_WITH_WIFI });
346 devicePtr->OnDeviceChanged(deviceInfo);
347
348 deviceInfo.networkType = NETWORKTYPE_NONE_WIFI;
349 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
350 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0))).WillOnce(Return(0));
351 devicePtr->OnDeviceChanged(deviceInfo);
352 devicePtr->cidNetTypeRecord_.erase(NETWORKID_TWO);
353 devicePtr->cidNetworkType_.erase(NETWORKID_TWO);
354 } catch (const exception &e) {
355 GTEST_LOG_(INFO) << e.what();
356 res = false;
357 }
358
359 EXPECT_TRUE(res);
360 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceChanged_0400 end";
361 }
362 /**
363 * @tc.name: DeviceManagerAgentTest_OnDeviceReady_0100
364 * @tc.desc: Verify the OnDeviceReady function.
365 * @tc.type: FUNC
366 * @tc.require: SR000H0387
367 */
368 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceReady_0100, TestSize.Level1)
369 {
370 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceReady_0100 start";
371 bool res = true;
372
373 try {
374 DeviceManagerAgent::GetInstance()->OnDeviceReady(deviceInfo);
375 } catch (const exception &e) {
376 LOGE("Error:%{public}s", e.what());
377 res = false;
378 }
379
380 EXPECT_TRUE(res == true);
381 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceReady_0100 end";
382 }
383
384 /**
385 * @tc.name: DeviceManagerAgentTest_OnDeviceP2POnline_0100
386 * @tc.desc: Verify the OnDeviceP2POnline function.
387 * @tc.type: FUNC
388 * @tc.require: I7M6L1
389 */
390 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceP2POnline_0100, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POnline_0100 start";
393 bool res = true;
394
395 try {
396 auto ret = DeviceManagerAgent::GetInstance()->OnDeviceP2POnline(deviceInfo);
397 EXPECT_EQ(ret, 1);
398 } catch (const exception &e) {
399 LOGE("Error:%{public}s", e.what());
400 res = false;
401 }
402
403 EXPECT_TRUE(res == true);
404 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POnline_0100 end";
405 }
406
407 /**
408 * @tc.name: DeviceManagerAgentTest_OnDeviceP2POnline_0200
409 * @tc.desc: Verify the OnDeviceP2POnline function.
410 * @tc.type: FUNC
411 * @tc.require: I7M6L1
412 */
413 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceP2POnline_0200, TestSize.Level1)
414 {
415 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POnline_0200 start";
416 bool res = true;
417
418 try {
419 std::vector<DmDeviceInfo> deviceList;
420 deviceList.push_back(deviceInfo);
421 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
422 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
423 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
424 auto agent1 = make_shared<SoftbusAgent>(smp);
425 string testNetWorkId = deviceInfo.networkId;
426 auto devicePtr = DeviceManagerAgent::GetInstance();
427 devicePtr->cidNetTypeRecord_.insert({ testNetWorkId, agent1 });
428 auto ret = DeviceManagerAgent::GetInstance()->OnDeviceP2POnline(deviceInfo);
429 EXPECT_EQ(ret, 1);
430
431 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
432 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0))).WillRepeatedly(Return(0));
433 devicePtr->cidNetworkType_.insert({ testNetWorkId, NETWORKTYPE_NONE_WIFI });
434 ret = devicePtr->OnDeviceP2POnline(deviceInfo);
435 EXPECT_EQ(ret, 0);
436 devicePtr->cidNetTypeRecord_.erase(testNetWorkId);
437 devicePtr->cidNetworkType_.erase(testNetWorkId);
438 } catch (const exception &e) {
439 GTEST_LOG_(INFO) << e.what();
440 res = false;
441 }
442
443 EXPECT_TRUE(res);
444 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POnline_0200 end";
445 }
446
447 /**
448 * @tc.name: DeviceManagerAgentTest_OnDeviceP2POffline_0100
449 * @tc.desc: Verify the OnDeviceP2POffline function.
450 * @tc.type: FUNC
451 * @tc.require: I7M6L1
452 */
453 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceP2POffline_0100, TestSize.Level1)
454 {
455 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POffline_0100 start";
456 bool res = true;
457
458 try {
459 auto ret = DeviceManagerAgent::GetInstance()->OnDeviceP2POffline(deviceInfo);
460 EXPECT_EQ(ret, 1);
461 } catch (const exception &e) {
462 LOGE("Error:%{public}s", e.what());
463 res = false;
464 }
465
466 EXPECT_TRUE(res == true);
467 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POffline_0100 end";
468 }
469
470 /**
471 * @tc.name: DeviceManagerAgentTest_OnDeviceP2POffline_0200
472 * @tc.desc: Verify the OnDeviceP2POffline function.
473 * @tc.type: FUNC
474 * @tc.require: I7M6L1
475 */
476 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceP2POffline_0200, TestSize.Level1)
477 {
478 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POffline_0200 start";
479 bool res = true;
480
481 try {
482 DeviceManagerAgent::GetInstance()->OnDeviceP2POnline(deviceInfo);
483 DeviceManagerAgent::GetInstance()->OnDeviceP2POffline(deviceInfo);
484 } catch (const exception &e) {
485 LOGE("Error:%{public}s", e.what());
486 res = false;
487 }
488
489 EXPECT_TRUE(res == true);
490 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POffline_0200 end";
491 }
492
493 /**
494 * @tc.name: DeviceManagerAgentTest_OnDeviceP2POffline_0300
495 * @tc.desc: Verify the OnDeviceP2POffline function.
496 * @tc.type: FUNC
497 * @tc.require: I7M6L1
498 */
499 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnDeviceP2POffline_0300, TestSize.Level1)
500 {
501 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POffline_0300 start";
502 bool res = true;
503
504 try {
505 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
506 auto agent1 = make_shared<SoftbusAgent>(smp);
507 (void)memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_NAME_LEN - 1,
508 NETWORKID_TWO.c_str(), NETWORKID_TWO.size());
509 auto devicePtr = DeviceManagerAgent::GetInstance();
510 devicePtr->cidNetTypeRecord_.clear();
511 devicePtr->cidNetworkType_.clear();
512 devicePtr->cidNetTypeRecord_.insert({ NETWORKID_TWO, agent1 });
513 auto ret = devicePtr->OnDeviceP2POffline(deviceInfo);
514 EXPECT_EQ(ret, 1);
515 devicePtr->cidNetworkType_.insert({ NETWORKID_TWO, NETWORKTYPE_NONE_WIFI });
516 ret = devicePtr->OnDeviceP2POffline(deviceInfo);
517 EXPECT_EQ(ret, 0);
518 auto iter = devicePtr->cidNetTypeRecord_.find(NETWORKID_TWO);
519 if (iter != devicePtr->cidNetTypeRecord_.end()) {
520 res = false;
521 }
522
523 auto iterType = devicePtr->cidNetworkType_.find(NETWORKID_TWO);
524 if (iterType != devicePtr->cidNetworkType_.end()) {
525 res = false;
526 }
527 } catch (const exception &e) {
528 GTEST_LOG_(INFO) << e.what();
529 res = false;
530 }
531
532 EXPECT_TRUE(res);
533 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnDeviceP2POffline_0300 end";
534 }
535
536 /**
537 * @tc.name: DeviceManagerAgentTest_StopInstance_0100
538 * @tc.desc: Verify the StopInstance function.
539 * @tc.type: FUNC
540 * @tc.require: I7TDJK
541 */
542 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_StopInstance_0100, TestSize.Level1)
543 {
544 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_StopInstance_0100 start";
545 bool res = true;
546
547 try {
548 DeviceManagerAgent::GetInstance()->StopInstance();
549 } catch (const exception &e) {
550 LOGE("Error:%{public}s", e.what());
551 res = false;
552 }
553
554 EXPECT_TRUE(res == true);
555 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_StopInstance_0100 end";
556 }
557
558 /**
559 * @tc.name: DeviceManagerAgentTest_Stop_0100
560 * @tc.desc: Verify the Stop function.
561 * @tc.type: FUNC
562 * @tc.require: I7TDJK
563 */
564 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_Stop_0100, TestSize.Level1)
565 {
566 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_Stop_0100 start";
567 bool res = true;
568
569 try {
570 DeviceManagerAgent::GetInstance()->Start();
571 DeviceManagerAgent::GetInstance()->Stop();
572 } catch (const exception &e) {
573 LOGE("Error:%{public}s", e.what());
574 res = false;
575 }
576
577 EXPECT_TRUE(res == true);
578 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_Stop_0100 end";
579 }
580
581 /**
582 * @tc.name: DeviceManagerAgentTest_JoinGroup_0100
583 * @tc.desc: Verify the JoinGroup function.
584 * @tc.type: FUNC
585 * @tc.require: I7TDJK
586 */
587 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_JoinGroup_0100, TestSize.Level1)
588 {
589 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_JoinGroup_0100 start";
590 bool res = true;
591
592 try {
593
594 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
595 DeviceManagerAgent::GetInstance()->JoinGroup(smp);
596 GTEST_LOG_(INFO) << smp->GetID();
597 auto it = DeviceManagerAgent::GetInstance()->mpToNetworks_.find(smp->GetID());
598 if (it == DeviceManagerAgent::GetInstance()->mpToNetworks_.end()) {
599 EXPECT_TRUE(false);
600 } else {
601 EXPECT_TRUE(true);
602 }
603 DeviceManagerAgent::GetInstance()->QuitGroup(smp);
604 it = DeviceManagerAgent::GetInstance()->mpToNetworks_.find(smp->GetID());
605 if (it == DeviceManagerAgent::GetInstance()->mpToNetworks_.end()) {
606 EXPECT_TRUE(true);
607 } else {
608 EXPECT_TRUE(false);
609 }
610 } catch (const exception &e) {
611 GTEST_LOG_(INFO) << e.what();
612 res = false;
613 }
614
615 EXPECT_TRUE(res == true);
616 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_JoinGroup_0100 end";
617 }
618
619 /**
620 * @tc.name: DeviceManagerAgentTest_JoinGroup_0200
621 * @tc.desc: Verify the JoinGroup function.
622 * @tc.type: FUNC
623 * @tc.require: I7TDJK
624 */
625 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_JoinGroup_0200, TestSize.Level1)
626 {
627 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_JoinGroup_0200 start";
628 bool res = true;
629
630 try {
631 weak_ptr<MountPoint> nullwmp;
632 DeviceManagerAgent::GetInstance()->JoinGroup(nullwmp);
633 } catch (const exception &e) {
634 EXPECT_EQ(string(e.what()), "Failed to join group: Received empty mountpoint");
635 res = false;
636 }
637
638 EXPECT_FALSE(res);
639 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_JoinGroup_0200 end";
640 }
641
642 /**
643 * @tc.name: DeviceManagerAgentTest_JoinGroup_0100
644 * @tc.desc: Verify the JoinGroup function.
645 * @tc.type: FUNC
646 * @tc.require: I7TDJK
647 */
648 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_JoinGroup_0300, TestSize.Level1)
649 {
650 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_JoinGroup_0300 start";
651 bool res = true;
652
653 try {
654 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
655 DeviceManagerAgent::GetInstance()->JoinGroup(smp);
656 DeviceManagerAgent::GetInstance()->JoinGroup(smp);
657 DeviceManagerAgent::GetInstance()->QuitGroup(smp);
658 } catch (const exception &e) {
659 EXPECT_EQ(string(e.what()), "Failed to join group: Mountpoint existed");
660 res = false;
661 }
662
663 EXPECT_FALSE(res);
664 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_JoinGroup_0300 end";
665 }
666
667 /**
668 * @tc.name: DeviceManagerAgentTest_QuitGroup_0100
669 * @tc.desc: Verify the QuitGroup function.
670 * @tc.type: FUNC
671 * @tc.require: I7TDJK
672 */
673 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_QuitGroup_0100, TestSize.Level1)
674 {
675 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_QuitGroup_0100 start";
676 bool res = true;
677
678 try {
679 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
680 DeviceManagerAgent::GetInstance()->QuitGroup(smp);
681 } catch (const exception &e) {
682 EXPECT_EQ(string(e.what()), "Failed to quit group: Mountpoint didn't exist ");
683 res = false;
684 }
685
686 EXPECT_TRUE(res != true);
687 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_QuitGroup_0100 end";
688 }
689
690 /**
691 * @tc.name: DeviceManagerAgentTest_QuitGroup_0200
692 * @tc.desc: Verify the QuitGroup function.
693 * @tc.type: FUNC
694 * @tc.require: I7TDJK
695 */
696 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_QuitGroup_0200, TestSize.Level1)
697 {
698 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_QuitGroup_0200 start";
699 bool res = true;
700
701 try {
702 shared_ptr<MountPoint> nullwmp;
703 DeviceManagerAgent::GetInstance()->QuitGroup(nullwmp);
704 } catch (const exception &e) {
705 EXPECT_EQ(string(e.what()), "Failed to quit group: Received empty mountpoint");
706 res = false;
707 }
708
709 EXPECT_FALSE(res);
710 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_QuitGroup_0200 end";
711 }
712
713 /**
714 * @tc.name: DeviceManagerAgentTest_OfflineAllDevice_0100
715 * @tc.desc: Verify the OfflineAllDevice function.
716 * @tc.type: FUNC
717 * @tc.require: I7TDJK
718 */
719 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OfflineAllDevice_0100, TestSize.Level1)
720 {
721 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OfflineAllDevice_0100 start";
722 bool res = true;
723
724 try {
725 DeviceManagerAgent::GetInstance()->OfflineAllDevice();
726 } catch (const exception &e) {
727 LOGE("Error:%{public}s", e.what());
728 res = false;
729 }
730
731 EXPECT_TRUE(res == true);
732 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OfflineAllDevice_0100 end";
733 }
734
735 /**
736 * @tc.name: DeviceManagerAgentTest_OfflineAllDevice_0200
737 * @tc.desc: Verify the OfflineAllDevice function.
738 * @tc.type: FUNC
739 * @tc.require: I7TDJK
740 */
741 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OfflineAllDevice_0200, TestSize.Level1)
742 {
743 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OfflineAllDevice_0200 start";
744 bool res = true;
745
746 try {
747 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
748 auto agent1 = make_shared<SoftbusAgent>(smp);
749 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.insert({ "test1", agent1 });
750 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.insert({ "test2", nullptr });
751
752 DeviceManagerAgent::GetInstance()->OfflineAllDevice();
753 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.erase("test1");
754 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.erase("test2");
755 } catch (const exception &e) {
756 GTEST_LOG_(INFO) << e.what();
757 res = false;
758 }
759
760 EXPECT_TRUE(res == true);
761 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OfflineAllDevice_0200 end";
762 }
763
764 /**
765 * @tc.name: DeviceManagerAgentTest_ReconnectOnlineDevices_0100
766 * @tc.desc: Verify the ReconnectOnlineDevices function.
767 * @tc.type: FUNC
768 * @tc.require: I7TDJK
769 */
770 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_ReconnectOnlineDevices_0100, TestSize.Level1)
771 {
772 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_ReconnectOnlineDevices_0100 start";
773 bool res = true;
774
775 try {
776 DeviceManagerAgent::GetInstance()->ReconnectOnlineDevices();
777 } catch (const exception &e) {
778 GTEST_LOG_(INFO) << e.what();
779 res = false;
780 }
781
782 EXPECT_TRUE(res == true);
783 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_ReconnectOnlineDevices_0100 end";
784 }
785
786 /**
787 * @tc.name: DeviceManagerAgentTest_ReconnectOnlineDevices_0200
788 * @tc.desc: Verify the ReconnectOnlineDevices function.
789 * @tc.type: FUNC
790 * @tc.require: I7TDJK
791 */
792 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_ReconnectOnlineDevices_0200, TestSize.Level1)
793 {
794 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_ReconnectOnlineDevices_0200 start";
795 bool res = true;
796
797 try {
798 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
799 auto agent1 = make_shared<SoftbusAgent>(smp);
800 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.insert({ "test1", agent1 });
801 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.insert({ "test2", nullptr });
802 DeviceManagerAgent::GetInstance()->ReconnectOnlineDevices();
803 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.erase("test1");
804 DeviceManagerAgent::GetInstance()->cidNetTypeRecord_.erase("test2");
805 } catch (const exception &e) {
806 GTEST_LOG_(INFO) << e.what();
807 res = false;
808 }
809
810 EXPECT_TRUE(res == true);
811 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_ReconnectOnlineDevices_0200 end";
812 }
813
814 /**
815 * @tc.name: DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0100
816 * @tc.desc: Verify the FindNetworkBaseTrustRelation function.
817 * @tc.type: FUNC
818 * @tc.require: I7TDJK
819 */
820 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0100, TestSize.Level1)
821 {
822 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0100 start";
823 bool res = true;
824
825 try {
826 auto rltPtr = DeviceManagerAgent::GetInstance()->FindNetworkBaseTrustRelation(true);
827 EXPECT_EQ(rltPtr, nullptr);
828 rltPtr = DeviceManagerAgent::GetInstance()->FindNetworkBaseTrustRelation(false);
829 EXPECT_EQ(rltPtr, nullptr);
830 } catch (const exception &e) {
831 LOGE("Error:%{public}s", e.what());
832 res = false;
833 }
834
835 EXPECT_TRUE(res == true);
836 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0100 end";
837 }
838
839 /**
840 * @tc.name: DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0200
841 * @tc.desc: Verify the FindNetworkBaseTrustRelation function.
842 * @tc.type: FUNC
843 * @tc.require: I7TDJK
844 */
845 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0200, TestSize.Level1)
846 {
847 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0200 start";
848 bool res = true;
849
850 try {
851 auto smp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(100, "relativePath"));
852 DeviceManagerAgent::GetInstance()->JoinGroup(smp);
853 auto rltPtr = DeviceManagerAgent::GetInstance()->FindNetworkBaseTrustRelation(true);
854 EXPECT_EQ(rltPtr, nullptr);
855 rltPtr = DeviceManagerAgent::GetInstance()->FindNetworkBaseTrustRelation(false);
856 EXPECT_NE(rltPtr, nullptr);
857 DeviceManagerAgent::GetInstance()->QuitGroup(smp);
858
859 } catch (const exception &e) {
860 LOGE("Error:%{public}s", e.what());
861 res = false;
862 }
863
864 EXPECT_TRUE(res == true);
865 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0200 end";
866 }
867
868 /**
869 * @tc.name: DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0300
870 * @tc.desc: Verify the FindNetworkBaseTrustRelation function.
871 * @tc.type: FUNC
872 * @tc.require: I7TDJK
873 */
874 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0300, TestSize.Level1)
875 {
876 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0300 start";
877 bool res = true;
878
879 try {
880 auto nonmp = make_shared<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(101, "non_account"));
881 DeviceManagerAgent::GetInstance()->JoinGroup(nonmp);
882 auto id = nonmp->GetID() + 1;
883 DeviceManagerAgent::GetInstance()->mpToNetworks_.insert({ id, nullptr });
884 shared_ptr<SoftbusAgent> agent = nullptr;
885 auto rltPtr = DeviceManagerAgent::GetInstance()->FindNetworkBaseTrustRelation(true);
886 EXPECT_NE(rltPtr, nullptr);
887 rltPtr = DeviceManagerAgent::GetInstance()->FindNetworkBaseTrustRelation(false);
888 EXPECT_EQ(rltPtr, nullptr);
889 DeviceManagerAgent::GetInstance()->QuitGroup(nonmp);
890 DeviceManagerAgent::GetInstance()->mpToNetworks_.erase(id);
891 } catch (const exception &e) {
892 LOGE("Error:%{public}s", e.what());
893 res = false;
894 }
895
896 EXPECT_TRUE(res == true);
897 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_FindNetworkBaseTrustRelation_0300 end";
898 }
899
900 /**
901 * @tc.name: DeviceManagerAgentTest_GetNetworkType_0100
902 * @tc.desc: Verify the GetNetworkType function.
903 * @tc.type: FUNC
904 * @tc.require: I7TDJK
905 */
906 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_GetNetworkType_0100, TestSize.Level1)
907 {
908 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetNetworkType_0100 start";
909 bool res = true;
910
911 try {
912 int ret = DeviceManagerAgent::GetInstance()->GetNetworkType(NETWORKID_ONE);
913 EXPECT_EQ(ret, 0);
914 ret = DeviceManagerAgent::GetInstance()->GetNetworkType(NETWORKID_TWO);
915 EXPECT_EQ(ret, NETWORKTYPE_WITH_WIFI);
916 ret = DeviceManagerAgent::GetInstance()->GetNetworkType(NETWORKID_THREE);
917 EXPECT_EQ(ret, NETWORKTYPE_NONE_WIFI);
918 } catch (const exception &e) {
919 LOGE("Error:%{public}s", e.what());
920 res = false;
921 }
922
923 EXPECT_TRUE(res == true);
924 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetNetworkType_0100 end";
925 }
926
927 /**
928 * @tc.name: DeviceManagerAgentTest_IsWifiNetworkType_0100
929 * @tc.desc: Verify the IsWifiNetworkType function.
930 * @tc.type: FUNC
931 * @tc.require: I7TDJK
932 */
933 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_IsWifiNetworkType_0100, TestSize.Level1)
934 {
935 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_IsWifiNetworkType_0100 start";
936 bool res = true;
937
938 try {
939 int ret = DeviceManagerAgent::GetInstance()->IsWifiNetworkType(-1);
940 EXPECT_FALSE(ret);
941 ret = DeviceManagerAgent::GetInstance()->IsWifiNetworkType(1);
942 EXPECT_FALSE(ret);
943 ret = DeviceManagerAgent::GetInstance()->IsWifiNetworkType(3);
944 EXPECT_TRUE(ret);
945 } catch (const exception &e) {
946 LOGE("Error:%{public}s", e.what());
947 res = false;
948 }
949
950 EXPECT_TRUE(res == true);
951 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_IsWifiNetworkType_0100 end";
952 }
953
954 /**
955 * @tc.name: DeviceManagerAgentTest_CheckIsAccountless_0100
956 * @tc.desc: Verify the CheckIsAccountless function.
957 * @tc.type: FUNC
958 * @tc.require: I7TDJK
959 */
960 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_CheckIsAccountless_0100, TestSize.Level1)
961 {
962 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_CheckIsAccountless_0100 start";
963 bool res = true;
964
965 try {
966 GroupInfo group{};
967 g_parameterVaule = false;
968 auto ret = DeviceManagerAgent::GetInstance()->CheckIsAccountless(group);
969 EXPECT_TRUE(ret);
970 } catch (const exception &e) {
971 GTEST_LOG_(INFO) << e.what();
972 res = false;
973 }
974
975 EXPECT_TRUE(res);
976 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_CheckIsAccountless_0100 end";
977 }
978
979 /**
980 * @tc.name: DeviceManagerAgentTest_CheckIsAccountless_0200
981 * @tc.desc: Verify the CheckIsAccountless function.
982 * @tc.type: FUNC
983 * @tc.require: I7TDJK
984 */
985 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_CheckIsAccountless_0200, TestSize.Level1)
986 {
987 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_CheckIsAccountless_0200 start";
988 bool res = true;
989
990 try {
991 GroupInfo group{};
992 g_parameterVaule = true;
993 auto ret = DeviceManagerAgent::GetInstance()->CheckIsAccountless(group);
994 EXPECT_FALSE(ret);
995 } catch (const exception &e) {
996 GTEST_LOG_(INFO) << e.what();
997 res = false;
998 }
999
1000 EXPECT_TRUE(res);
1001 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_CheckIsAccountless_0200 end";
1002 }
1003
1004 /**
1005 * @tc.name: DeviceManagerAgentTest_InitDeviceInfos_0100
1006 * @tc.desc: Verify the InitDeviceInfos function.
1007 * @tc.type: FUNC
1008 * @tc.require: I7TDJK
1009 */
1010 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_InitDeviceInfos_0100, TestSize.Level1)
1011 {
1012 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitDeviceInfos_0100 start";
1013 bool res = true;
1014
1015 try {
1016 std::vector<DmDeviceInfo> deviceList;
1017 deviceList.push_back(deviceInfo);
1018 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
1019 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)))
1020 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
1021 DeviceManagerAgent::GetInstance()->InitDeviceInfos();
1022 } catch (const exception &e) {
1023 GTEST_LOG_(INFO) << e.what();
1024 res = false;
1025 }
1026
1027 EXPECT_TRUE(res == true);
1028 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitDeviceInfos_0100 end";
1029 }
1030
1031 /**
1032 * @tc.name: DeviceManagerAgentTest_InitDeviceInfos_0200
1033 * @tc.desc: Verify the InitDeviceInfos function.
1034 * @tc.type: FUNC
1035 * @tc.require: I7TDJK
1036 */
1037 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_InitDeviceInfos_0200, TestSize.Level1)
1038 {
1039 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitDeviceInfos_0200 start";
1040 bool res = true;
1041
1042 try {
1043 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _)).WillOnce(Return(-1));
1044 DeviceManagerAgent::GetInstance()->InitDeviceInfos();
1045 } catch (const exception &e) {
1046 GTEST_LOG_(INFO) << e.what();
1047 res = false;
1048 }
1049
1050 EXPECT_FALSE(res);
1051 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitDeviceInfos_0200 end";
1052 }
1053
1054 /**
1055 * @tc.name: DeviceManagerAgentTest_InitDeviceInfos_0300
1056 * @tc.desc: Verify the InitDeviceInfos function.
1057 * @tc.type: FUNC
1058 * @tc.require: I7TDJK
1059 */
1060 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_InitDeviceInfos_0300, TestSize.Level1)
1061 {
1062 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitDeviceInfos_0300 start";
1063 bool res = true;
1064
1065 try {
1066 std::vector<DmDeviceInfo> deviceList;
1067 deviceList.push_back(deviceInfo);
1068 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
1069 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0))).WillOnce(Return(0));
1070 DeviceManagerAgent::GetInstance()->InitDeviceInfos();
1071 } catch (const exception &e) {
1072 GTEST_LOG_(INFO) << e.what();
1073 res = false;
1074 }
1075
1076 EXPECT_TRUE(res);
1077 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitDeviceInfos_0300 end";
1078 }
1079
1080 /**
1081 * @tc.name: DeviceManagerAgentTest_InitLocalNodeInfo_0100
1082 * @tc.desc: Verify the InitLocalNodeInfo function.
1083 * @tc.type: FUNC
1084 * @tc.require: I7TDJK
1085 */
1086 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_InitLocalNodeInfo_0100, TestSize.Level1)
1087 {
1088 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitLocalNodeInfo_0100 start";
1089 bool res = true;
1090
1091 try {
1092 EXPECT_CALL(*deviceManagerImplMock_, GetLocalDeviceInfo(_, _)).WillOnce(Return(0));
1093 DeviceManagerAgent::GetInstance()->InitLocalNodeInfo();
1094 } catch (const exception &e) {
1095 LOGE("Error:%{public}s", e.what());
1096 res = false;
1097 }
1098
1099 EXPECT_TRUE(res == true);
1100 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitLocalNodeInfo_0100 end";
1101 }
1102
1103 /**
1104 * @tc.name: DeviceManagerAgentTest_InitLocalNodeInfo_0100
1105 * @tc.desc: Verify the InitLocalNodeInfo function.
1106 * @tc.type: FUNC
1107 * @tc.require: I7TDJK
1108 */
1109 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_InitLocalNodeInfo_0200, TestSize.Level1)
1110 {
1111 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitLocalNodeInfo_0200 start";
1112 bool res = true;
1113
1114 try {
1115 EXPECT_CALL(*deviceManagerImplMock_, GetLocalDeviceInfo(_, _)).WillOnce(Return(-1));
1116 DeviceManagerAgent::GetInstance()->InitLocalNodeInfo();
1117 } catch (const exception &e) {
1118 GTEST_LOG_(INFO) << e.what();
1119 res = false;
1120 }
1121
1122 EXPECT_FALSE(res);
1123 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_InitLocalNodeInfo_0200 end";
1124 }
1125
1126 /**
1127 * @tc.name: DeviceManagerAgentTest_OnRemoteDied_0100
1128 * @tc.desc: Verify the OnRemoteDied function.
1129 * @tc.type: FUNC
1130 * @tc.require: I7TDJK
1131 */
1132 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_OnRemoteDied_0100, TestSize.Level1)
1133 {
1134 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnRemoteDied_0100 start";
1135 bool res = true;
1136
1137 try {
1138 DeviceManagerAgent::GetInstance()->OnRemoteDied();
1139 } catch (const exception &e) {
1140 LOGE("Error:%{public}s", e.what());
1141 res = false;
1142 }
1143
1144 EXPECT_TRUE(res == true);
1145 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_OnRemoteDied_0100 end";
1146 }
1147
1148 /**
1149 * @tc.name: DeviceManagerAgentTest_GetLocalDeviceInfo_0100
1150 * @tc.desc: Verify the GetLocalDeviceInfo function.
1151 * @tc.type: FUNC
1152 * @tc.require: I7TDJK
1153 */
1154 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_GetLocalDeviceInfo_0100, TestSize.Level1)
1155 {
1156 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetLocalDeviceInfo_0100 start";
1157 bool res = true;
1158
1159 try {
1160 DeviceManagerAgent::GetInstance()->GetLocalDeviceInfo();
1161 } catch (const exception &e) {
1162 LOGE("Error:%{public}s", e.what());
1163 res = false;
1164 }
1165
1166 EXPECT_TRUE(res == true);
1167 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetLocalDeviceInfo_0100 end";
1168 }
1169
1170 /**
1171 * @tc.name: DeviceManagerAgentTest_GetRemoteDevicesInfo_0100
1172 * @tc.desc: Verify the GetRemoteDevicesInfo function.
1173 * @tc.type: FUNC
1174 * @tc.require: I7TDJK
1175 */
1176 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_GetRemoteDevicesInfo_0100, TestSize.Level1)
1177 {
1178 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetRemoteDevicesInfo_0100 start";
1179 bool res = true;
1180
1181 try {
1182 std::vector<DmDeviceInfo> deviceList;
1183 deviceList.push_back(deviceInfo);
1184 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
1185 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
1186 auto info = DeviceManagerAgent::GetInstance()->GetRemoteDevicesInfo();
1187 EXPECT_NE(info.size(), 0);
1188 } catch (const exception &e) {
1189 GTEST_LOG_(INFO) << e.what();
1190 res = false;
1191 }
1192
1193 EXPECT_TRUE(res == true);
1194 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetRemoteDevicesInfo_0100 end";
1195 }
1196
1197 /**
1198 * @tc.name: DeviceManagerAgentTest_GetRemoteDevicesInfo_0200
1199 * @tc.desc: Verify the GetRemoteDevicesInfo function.
1200 * @tc.type: FUNC
1201 * @tc.require: I7TDJK
1202 */
1203 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_GetRemoteDevicesInfo_0200, TestSize.Level1)
1204 {
1205 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetRemoteDevicesInfo_0200 start";
1206 bool res = true;
1207
1208 try {
1209 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _)).WillOnce(Return(-1));
1210 auto info = DeviceManagerAgent::GetInstance()->GetRemoteDevicesInfo();
1211 EXPECT_NE(info.size(), 0);
1212 } catch (const exception &e) {
1213 GTEST_LOG_(INFO) << e.what();
1214 res = false;
1215 }
1216
1217 EXPECT_FALSE(res);
1218 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_GetRemoteDevicesInfo_0200 end";
1219 }
1220
1221 /**
1222 * @tc.name: DeviceManagerAgentTest_RegisterToExternalDm_0100
1223 * @tc.desc: Verify the RegisterToExternalDm function.
1224 * @tc.type: FUNC
1225 * @tc.require: I7TDJK
1226 */
1227 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_RegisterToExternalDm_0100, TestSize.Level1)
1228 {
1229 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_RegisterToExternalDm_0100 start";
1230 bool res = true;
1231
1232 try {
1233 EXPECT_CALL(*deviceManagerImplMock_, InitDeviceManager(_, _)).WillOnce(Return(-1));
1234 DeviceManagerAgent::GetInstance()->RegisterToExternalDm();
1235 } catch (const exception &e) {
1236 string errMsg = e.what();
1237 EXPECT_NE(errMsg.find("Failed to InitDeviceManager"), string::npos);
1238 res = false;
1239 }
1240
1241 EXPECT_FALSE(res);
1242 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_RegisterToExternalDm_0100 end";
1243 }
1244
1245 /**
1246 * @tc.name: DeviceManagerAgentTest_RegisterToExternalDm_0100
1247 * @tc.desc: Verify the RegisterToExternalDm function.
1248 * @tc.type: FUNC
1249 * @tc.require: I7TDJK
1250 */
1251 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_RegisterToExternalDm_0200, TestSize.Level1)
1252 {
1253 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_RegisterToExternalDm_0200 start";
1254 bool res = true;
1255
1256 try {
1257 EXPECT_CALL(*deviceManagerImplMock_, InitDeviceManager(_, _)).WillOnce(Return(0));
1258 EXPECT_CALL(*deviceManagerImplMock_, RegisterDevStateCallback(_, _, _)).WillOnce(Return(-1));
1259 DeviceManagerAgent::GetInstance()->RegisterToExternalDm();
1260 } catch (const exception &e) {
1261 string errMsg = e.what();
1262 EXPECT_NE(errMsg.find("Failed to RegisterDevStateCallback"), string::npos);
1263 res = false;
1264 }
1265
1266 EXPECT_FALSE(res);
1267 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_RegisterToExternalDm_0200 end";
1268 }
1269
1270 /**
1271 * @tc.name: DeviceManagerAgentTest_RegisterToExternalDm_0300
1272 * @tc.desc: Verify the RegisterToExternalDm function.
1273 * @tc.type: FUNC
1274 * @tc.require: I7TDJK
1275 */
1276 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_RegisterToExternalDm_0300, TestSize.Level1)
1277 {
1278 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_RegisterToExternalDm_0300 start";
1279 bool res = true;
1280
1281 try {
1282 EXPECT_CALL(*deviceManagerImplMock_, InitDeviceManager(_, _)).WillOnce(Return(0));
1283 EXPECT_CALL(*deviceManagerImplMock_, RegisterDevStateCallback(_, _, _)).WillOnce(Return(0));
1284 DeviceManagerAgent::GetInstance()->RegisterToExternalDm();
1285 } catch (const exception &e) {
1286 GTEST_LOG_(INFO) << e.what();
1287 res = false;
1288 }
1289
1290 EXPECT_TRUE(res);
1291 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_RegisterToExternalDm_0300 end";
1292 }
1293
1294 /**
1295 * @tc.name: DeviceManagerAgentTest_UnregisterFromExternalDm_0100
1296 * @tc.desc: Verify the UnregisterFromExternalDm function.
1297 * @tc.type: FUNC
1298 * @tc.require: I7TDJK
1299 */
1300 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_UnregisterFromExternalDm_0100, TestSize.Level1)
1301 {
1302 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_UnregisterFromExternalDm_0100 start";
1303 bool res = true;
1304
1305 try {
1306 EXPECT_CALL(*deviceManagerImplMock_, UnRegisterDevStateCallback(_)).WillOnce(Return(-1));
1307 DeviceManagerAgent::GetInstance()->UnregisterFromExternalDm();
1308 } catch (const exception &e) {
1309 string errMsg = e.what();
1310 EXPECT_NE(errMsg.find("Failed to UnRegisterDevStateCallback"), string::npos);
1311 res = false;
1312 }
1313
1314 EXPECT_FALSE(res);
1315 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_UnregisterFromExternalDm_0100 end";
1316 }
1317
1318 /**
1319 * @tc.name: DeviceManagerAgentTest_UnregisterFromExternalDm_0200
1320 * @tc.desc: Verify the UnregisterFromExternalDm function.
1321 * @tc.type: FUNC
1322 * @tc.require: I7TDJK
1323 */
1324 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_UnregisterFromExternalDm_0200, TestSize.Level1)
1325 {
1326 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_UnregisterFromExternalDm_0200 start";
1327 bool res = true;
1328
1329 try {
1330 EXPECT_CALL(*deviceManagerImplMock_, UnRegisterDevStateCallback(_)).WillOnce(Return(0));
1331 EXPECT_CALL(*deviceManagerImplMock_, UnInitDeviceManager(_)).WillOnce(Return(-1));
1332 DeviceManagerAgent::GetInstance()->UnregisterFromExternalDm();
1333 } catch (const exception &e) {
1334 string errMsg = e.what();
1335 EXPECT_NE(errMsg.find("Failed to UnInitDeviceManager"), string::npos);
1336 res = false;
1337 }
1338
1339 EXPECT_FALSE(res);
1340 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_UnregisterFromExternalDm_0200 end";
1341 }
1342
1343 /**
1344 * @tc.name: DeviceManagerAgentTest_UnregisterFromExternalDm_0300
1345 * @tc.desc: Verify the UnregisterFromExternalDm function.
1346 * @tc.type: FUNC
1347 * @tc.require: I7TDJK
1348 */
1349 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_UnregisterFromExternalDm_0300, TestSize.Level1)
1350 {
1351 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_UnregisterFromExternalDm_0300 start";
1352 bool res = true;
1353
1354 try {
1355 EXPECT_CALL(*deviceManagerImplMock_, UnRegisterDevStateCallback(_)).WillOnce(Return(0));
1356 EXPECT_CALL(*deviceManagerImplMock_, UnInitDeviceManager(_)).WillOnce(Return(0));
1357 DeviceManagerAgent::GetInstance()->UnregisterFromExternalDm();
1358 } catch (const exception &e) {
1359 GTEST_LOG_(INFO) << e.what();
1360 res = false;
1361 }
1362
1363 EXPECT_TRUE(res);
1364 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_UnregisterFromExternalDm_0300 end";
1365 }
1366
1367 /**
1368 * @tc.name: DeviceManagerAgentTest_QueryRelatedGroups_0100
1369 * @tc.desc: Verify the QueryRelatedGroups function.
1370 * @tc.type: FUNC
1371 * @tc.require: I7TDJK
1372 */
1373 HWTEST_F(DeviceManagerAgentTest, DeviceManagerAgentTest_QueryRelatedGroups_0100, TestSize.Level1)
1374 {
1375 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_QueryRelatedGroups_0100 start";
1376 bool res = true;
1377
1378 try {
1379 DeviceManagerAgent::GetInstance()->QueryRelatedGroups("100", "100");
1380 } catch (const exception &e) {
1381 LOGE("Error:%{public}s", e.what());
1382 res = false;
1383 }
1384
1385 EXPECT_TRUE(res == true);
1386 GTEST_LOG_(INFO) << "DeviceManagerAgentTest_QueryRelatedGroups_0100 end";
1387 }
1388 } // namespace Test
1389 } // namespace DistributedFile
1390 } // namespace Storage
1391 } // namespace OHOS
1392