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