1 /*
2 * Copyright (c) 2024-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 "network/softbus/softbus_agent.h"
16
17 #include "gtest/gtest.h"
18 #include <memory>
19 #include <unistd.h>
20
21 #include "device_manager_agent_mock.h"
22 #include "device_manager_impl_mock.h"
23 #include "dm_constants.h"
24 #include "softbus_error_code.h"
25
26 #include "network/softbus/softbus_session_dispatcher.h"
27 #include "network/softbus/softbus_session.h"
28 #include "utils_log.h"
29 #include "socket_mock.h"
30
31 using namespace std;
32 namespace {
33 const string NETWORKID_ONE = "45656596896323231";
34 const string NETWORKID_TWO = "45656596896323232";
35 const string NETWORKID_THREE = "45656596896323233";
36 constexpr int32_t NETWORKTYPE_WITH_WIFI = 2;
37 constexpr int32_t NETWORKTYPE_NONE_WIFI = 4;
38 }
39 namespace OHOS {
40 namespace Storage {
41 namespace DistributedFile {
42 namespace Test {
43 using namespace testing;
44 using namespace testing::ext;
45 constexpr int USER_ID = 100;
46 constexpr int MAX_RETRY_COUNT = 7;
47 constexpr int DEFAULT_VALUE = -1;
48 static const string SAME_ACCOUNT = "account";
49 const string SESSION_NAME = "DistributedFileService/mnt/hmdfs/100/account";
50
51 class SoftbusAgentTest : public testing::Test {
52 public:
53 static void SetUpTestCase(void);
54 static void TearDownTestCase(void);
SetUp()55 void SetUp() {};
TearDown()56 void TearDown() {};
57 void CreateDeviceList(std::vector<DmDeviceInfo> &deviceList);
58
59 static inline shared_ptr<SocketMock> socketMock_ = nullptr;
60 static inline std::shared_ptr<DeviceManagerAgentMock> deviceManagerAgentMock_ = nullptr;
61 static inline shared_ptr<DeviceManagerImplMock> deviceManagerImplMock_ = nullptr;
62 };
63
64
CreateDeviceList(std::vector<DmDeviceInfo> & deviceList)65 void SoftbusAgentTest::CreateDeviceList(std::vector<DmDeviceInfo> &deviceList)
66 {
67 DmDeviceInfo testInfo;
68 (void)memcpy_s(testInfo.networkId, DM_MAX_DEVICE_ID_LEN - 1,
69 NETWORKID_ONE.c_str(), NETWORKID_ONE.size());
70 testInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
71 deviceList.push_back(testInfo);
72
73 DmDeviceInfo testInfo1;
74 (void)memcpy_s(testInfo1.networkId, DM_MAX_DEVICE_ID_LEN - 1,
75 NETWORKID_TWO.c_str(), NETWORKID_TWO.size());
76 testInfo1.authForm = DmAuthForm::PEER_TO_PEER;
77 deviceList.push_back(testInfo1);
78 }
79
SetUpTestCase(void)80 void SoftbusAgentTest::SetUpTestCase(void)
81 {
82 GTEST_LOG_(INFO) << "SetUpTestCase";
83 socketMock_ = make_shared<SocketMock>();
84 SocketMock::dfsSocket = socketMock_;
85 deviceManagerAgentMock_ = std::make_shared<DeviceManagerAgentMock>();
86 IDeviceManagerAgentMock::iDeviceManagerAgentMock_ = deviceManagerAgentMock_;
87 deviceManagerImplMock_ = make_shared<DeviceManagerImplMock>();
88 DeviceManagerImplMock::dfsDeviceManagerImpl = deviceManagerImplMock_;
89 }
90
TearDownTestCase(void)91 void SoftbusAgentTest::TearDownTestCase(void)
92 {
93 GTEST_LOG_(INFO) << "TearDownTestCase";
94 SocketMock::dfsSocket = nullptr;
95 socketMock_ = nullptr;
96 IDeviceManagerAgentMock::iDeviceManagerAgentMock_ = nullptr;
97 deviceManagerAgentMock_ = nullptr;
98 DeviceManagerImplMock::dfsDeviceManagerImpl = nullptr;
99 deviceManagerImplMock_ = nullptr;
100 }
101
102 /**
103 * @tc.name: SoftbusAgentTest_SoftbusAgent_0100
104 * @tc.desc: Verify the SoftbusAgent function.
105 * @tc.type: FUNC
106 * @tc.require: I9JXPR
107 */
108 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_SoftbusAgent_0100, TestSize.Level1)
109 {
110 GTEST_LOG_(INFO) << "SoftbusAgentTest_SoftbusAgent_0100 start";
111 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
112 shared_ptr<MountPoint> smp = move(mp);
113 weak_ptr<MountPoint> wmp(smp);
114 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
115 EXPECT_EQ(agent->sessionName_, SESSION_NAME);
116
117 weak_ptr<MountPoint> nullwmp;
118 std::shared_ptr<SoftbusAgent> agent2 = std::make_shared<SoftbusAgent>(nullwmp);
119 EXPECT_EQ(agent2->sessionName_, SESSION_NAME);
120 GTEST_LOG_(INFO) << "SoftbusAgentTest_SoftbusAgent_0100 end";
121 }
122
123 /**
124 * @tc.name: SoftbusAgentTest_QuitDomain_0100
125 * @tc.desc: Verify the QuitDomain.
126 * @tc.type: FUNC
127 * @tc.require: I9JXPR
128 */
129 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_QuitDomain_0100, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "SoftbusAgentTest_QuitDomain_0100 start";
132 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
133 shared_ptr<MountPoint> smp = move(mp);
134 weak_ptr<MountPoint> wmp(smp);
135 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
136 bool res = true;
137 try {
138 agent->QuitDomain();
139 } catch (const exception &e) {
140 res = false;
141 GTEST_LOG_(INFO) << e.what();
142 }
143 EXPECT_TRUE(res == false);
144 GTEST_LOG_(INFO) << "SoftbusAgentTest_QuitDomain_0100 end";
145 }
146
147 /**
148 * @tc.name: SoftbusAgentTest_QuitDomain_0200
149 * @tc.desc: Verify the QuitDomain.
150 * @tc.type: FUNC
151 * @tc.require: I9JXPR
152 */
153 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_QuitDomain_0200, TestSize.Level1)
154 {
155 GTEST_LOG_(INFO) << "SoftbusAgentTest_QuitDomain_0200 start";
156 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
157 shared_ptr<MountPoint> smp = move(mp);
158 weak_ptr<MountPoint> wmp(smp);
159 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
160 weak_ptr<SoftbusAgent> wsba(agent);
161 string busName = "test";
162 bool res = true;
163 try {
164 agent->serverIdMap_.insert(std::make_pair(busName, 1));
165 agent->QuitDomain();
166 agent->serverIdMap_.erase(busName);
167 } catch (const exception &e) {
168 res = false;
169 GTEST_LOG_(INFO) << e.what();
170 }
171 EXPECT_TRUE(res == false);
172 GTEST_LOG_(INFO) << "SoftbusAgentTest_QuitDomain_0200 end";
173 }
174
175 /**
176 * @tc.name: SoftbusAgentTest_QuitDomain_0300
177 * @tc.desc: Verify the QuitDomain.
178 * @tc.type: FUNC
179 * @tc.require: I9JXPR
180 */
181 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_QuitDomain_0300, TestSize.Level1)
182 {
183 GTEST_LOG_(INFO) << "SoftbusAgentTest_QuitDomain_0300 start";
184 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
185 shared_ptr<MountPoint> smp = move(mp);
186 weak_ptr<MountPoint> wmp(smp);
187 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
188 bool res = true;
189 weak_ptr<SoftbusAgent> wsba(agent);
190 string busName = agent->sessionName_;
191 try {
192 SoftbusSessionDispatcher::RegisterSessionListener(busName, wsba);
193 agent->serverIdMap_.insert(std::make_pair(busName, 1));
194 agent->QuitDomain();
195 auto agentRlt = SoftbusSessionDispatcher::busNameToAgent_.find(busName);
196 if (agentRlt != SoftbusSessionDispatcher::busNameToAgent_.end()) {
197 EXPECT_TRUE(false);
198 } else {
199 EXPECT_TRUE(true);
200 }
201 agent->serverIdMap_.erase(busName);
202 } catch (const exception &e) {
203 res = false;
204 GTEST_LOG_(INFO) << e.what();
205 }
206 EXPECT_TRUE(res);
207 GTEST_LOG_(INFO) << "SoftbusAgentTest_QuitDomain_0300 end";
208 }
209
210 /**
211 * @tc.name: SoftbusAgentTest_OnSessionClosed_0100
212 * @tc.desc: Verify the OnSessionClosed function.
213 * @tc.type: FUNC
214 * @tc.require: SR000H0387
215 */
216 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_OnSessionClosed_0100, TestSize.Level1)
217 {
218 GTEST_LOG_(INFO) << "SoftbusAgentTest_OnSessionClosed_0100 start";
219 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
220 shared_ptr<MountPoint> smp = move(mp);
221 weak_ptr<MountPoint> wmp(smp);
222 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
223 const int sessionId = 1;
224 bool res = true;
225 std::string peerDeviceId = "f6d4c0864707aefte7a78f09473aa122ff57fc8";
226 try {
227 agent->OnSessionClosed(sessionId, peerDeviceId);
228 } catch (const exception &e) {
229 res = false;
230 LOGE("%{public}s", e.what());
231 }
232 EXPECT_TRUE(res == true);
233 GTEST_LOG_(INFO) << "SoftbusAgentTest_OnSessionClosed_0100 end";
234 }
235
236 /**
237 * @tc.name: SoftbusAgentTest_JoinDomain_0100
238 * @tc.desc: Verify the Start function.
239 * @tc.type: FUNC
240 * @tc.require: I9JXPR
241 */
242 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_JoinDomain_0100, TestSize.Level1)
243 {
244 GTEST_LOG_(INFO) << "SoftbusAgentTest_JoinDomain_0100 start";
245 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
246 shared_ptr<MountPoint> smp = move(mp);
247 weak_ptr<MountPoint> wmp(smp);
248 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
249 bool res = true;
250 try {
251 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
252 agent->JoinDomain();
253 EXPECT_NE(SoftbusSessionDispatcher::busNameToAgent_.find(agent->sessionName_),
254 SoftbusSessionDispatcher::busNameToAgent_.end());
255 EXPECT_EQ(agent->serverIdMap_.find(agent->sessionName_),
256 agent->serverIdMap_.end());
257 SoftbusSessionDispatcher::busNameToAgent_.erase(agent->sessionName_);
258
259 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
260 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(0));
261 agent->JoinDomain();
262 EXPECT_NE(agent->serverIdMap_.find(agent->sessionName_),
263 agent->serverIdMap_.end());
264 agent->serverIdMap_.erase(agent->sessionName_);
265 SoftbusSessionDispatcher::busNameToAgent_.erase(agent->sessionName_);
266 GTEST_LOG_(INFO) << "3";
267 } catch (const exception &e) {
268 res = false;
269 LOGE("%{public}s", e.what());
270 }
271 EXPECT_TRUE(res);
272 GTEST_LOG_(INFO) << "SoftbusAgentTest_JoinDomain_0100 end";
273 }
274
275 /**
276 * @tc.name: SoftbusAgentTest_JoinDomain_0200
277 * @tc.desc: Verify the Start function.
278 * @tc.type: FUNC
279 * @tc.require: I9JXPR
280 */
281 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_JoinDomain_0200, TestSize.Level1)
282 {
283 GTEST_LOG_(INFO) << "SoftbusAgentTest_JoinDomain_0200 start";
284 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
285 shared_ptr<MountPoint> smp = move(mp);
286 weak_ptr<MountPoint> wmp(smp);
287 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
288 bool res = true;
289 try {
290 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(1));
291 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(-1));
292 agent->JoinDomain();
293 } catch (...) {
294 res = false;
295 EXPECT_NE(SoftbusSessionDispatcher::busNameToAgent_.find(agent->sessionName_),
296 SoftbusSessionDispatcher::busNameToAgent_.end());
297 SoftbusSessionDispatcher::busNameToAgent_.erase(agent->sessionName_);
298 }
299 EXPECT_FALSE(res);
300 GTEST_LOG_(INFO) << "SoftbusAgentTest_JoinDomain_0200 end";
301 }
302
303 /**
304 * @tc.name: SoftbusAgentTest_Stop_0100
305 * @tc.desc: Verify the Stop function.
306 * @tc.type: FUNC
307 * @tc.require: SR000H0387
308 */
309 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_Stop_0100, TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "SoftbusAgentTest_Stop_0100 start";
312 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
313 shared_ptr<MountPoint> smp = move(mp);
314 weak_ptr<MountPoint> wmp(smp);
315 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
316 bool res = true;
317 try {
318 SoftbusSessionDispatcher::busNameToAgent_.erase(agent->sessionName_);
319 agent->Stop();
320 } catch (const exception &e) {
321 res = false;
322 LOGE("%{public}s", e.what());
323 }
324 EXPECT_FALSE(res);
325 GTEST_LOG_(INFO) << "SoftbusAgentTest_Stop_0100 end";
326 }
327
328 /**
329 * @tc.name: SoftbusAgentTest_ConnectOnlineDevices_0100
330 * @tc.desc: Verify the ConnectOnlineDevices function.
331 * @tc.type: FUNC
332 * @tc.require: SR000H0387
333 */
334 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_ConnectOnlineDevices_0100, TestSize.Level1)
335 {
336 GTEST_LOG_(INFO) << "SoftbusAgentTest_ConnectOnlineDevices_0100 start";
337 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
338 shared_ptr<MountPoint> smp = move(mp);
339 weak_ptr<MountPoint> wmp(smp);
340 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
341 bool res = true;
342 try {
343 vector<DeviceInfo> deviceInfos;
344 DeviceInfo deviceInfo;
345 deviceInfo.SetCid("test");
346 deviceInfos.emplace_back(deviceInfo);
347 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo())
348 .WillOnce(Return(deviceInfos));
349 agent->ConnectOnlineDevices();
350
351 deviceInfo.extraData_ = " ";
352 deviceInfos.clear();
353 deviceInfos.emplace_back(deviceInfo);
354 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo())
355 .WillOnce(Return(deviceInfos));
356 agent->ConnectOnlineDevices();
357
358 deviceInfo.extraData_ = "{\"OS_TYPE\":\"test\"}";
359 deviceInfos.clear();
360 deviceInfos.emplace_back(deviceInfo);
361 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo())
362 .WillOnce(Return(deviceInfos));
363 agent->ConnectOnlineDevices();
364
365 deviceInfo.extraData_ = "{\"OS_TYPE\":0}";
366 deviceInfos.clear();
367 deviceInfos.emplace_back(deviceInfo);
368 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo())
369 .WillOnce(Return(deviceInfos));
370 agent->ConnectOnlineDevices();
371 } catch (const exception &e) {
372 res = false;
373 LOGE("%{public}s", e.what());
374 }
375 EXPECT_TRUE(res);
376 GTEST_LOG_(INFO) << "SoftbusAgentTest_ConnectOnlineDevices_0100 end";
377 }
378
379 /**
380 * @tc.name: SoftbusAgentTest_ConnectOnlineDevices_0200
381 * @tc.desc: Verify the ConnectOnlineDevices function.
382 * @tc.type: FUNC
383 * @tc.require: I9JXPR
384 */
385 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_ConnectOnlineDevices_0200, TestSize.Level1)
386 {
387 GTEST_LOG_(INFO) << "SoftbusAgentTest_ConnectOnlineDevices_0200 start";
388 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
389 shared_ptr<MountPoint> smp = move(mp);
390 weak_ptr<MountPoint> wmp(smp);
391 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
392 bool res = true;
393 try {
394 vector<DeviceInfo> deviceInfos;
395 DeviceInfo deviceInfo;
396 deviceInfo.SetCid("test");
397 deviceInfo.extraData_ = "{\"OS_TYPE\":10}";
398 deviceInfos.emplace_back(deviceInfo);
399 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo())
400 .WillOnce(Return(deviceInfos));
401 EXPECT_CALL(*deviceManagerImplMock_, GetNetworkTypeByNetworkId(_, _, _))
402 .WillOnce(Return(DEFAULT_VALUE));
403 agent->ConnectOnlineDevices();
404
405 deviceInfo.extraData_ = "{\"OS_TYPE\":10}";
406 deviceInfos.clear();
407 deviceInfos.emplace_back(deviceInfo);
408 int32_t networkType = 0;
409 networkType = NETWORKTYPE_WITH_WIFI;
410 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo())
411 .WillOnce(Return(deviceInfos));
412 EXPECT_CALL(*deviceManagerImplMock_, GetNetworkTypeByNetworkId(_, _, _))
413 .WillOnce(DoAll(SetArgReferee<2>(networkType), Return(0)));
414 agent->ConnectOnlineDevices();
415
416 deviceInfo.extraData_ = "{\"OS_TYPE\":10}";
417 deviceInfos.clear();
418 deviceInfos.emplace_back(deviceInfo);
419 networkType = NETWORKTYPE_NONE_WIFI;
420 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo())
421 .WillOnce(Return(deviceInfos));
422 EXPECT_CALL(*deviceManagerImplMock_, GetNetworkTypeByNetworkId(_, _, _))
423 .WillOnce(DoAll(SetArgReferee<2>(networkType), Return(0)));
424 agent->ConnectOnlineDevices();
425 } catch (const exception &e) {
426 res = false;
427 LOGE("%{public}s", e.what());
428 }
429 EXPECT_TRUE(res);
430 GTEST_LOG_(INFO) << "SoftbusAgentTest_ConnectOnlineDevices_0200 end";
431 }
432
433 /**
434 * @tc.name: SoftbusAgentTest_DisconnectAllDevices_0100
435 * @tc.desc: Verify the DisconnectAllDevices function.
436 * @tc.type: FUNC
437 * @tc.require: SR000H0387
438 */
439 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_DisconnectAllDevices_0100, TestSize.Level1)
440 {
441 GTEST_LOG_(INFO) << "SoftbusAgentTest_DisconnectAllDevices_0100 start";
442 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
443 shared_ptr<MountPoint> smp = move(mp);
444 weak_ptr<MountPoint> wmp(smp);
445 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
446 bool res = true;
447 try {
448 agent->DisconnectAllDevices();
449 } catch (const exception &e) {
450 res = false;
451 LOGE("%{public}s", e.what());
452 }
453 EXPECT_TRUE(res == true);
454 GTEST_LOG_(INFO) << "SoftbusAgentTest_DisconnectAllDevices_0100 end";
455 }
456
457 /**
458 * @tc.name: SoftbusAgentTest_AcceptSession_0100
459 * @tc.desc: Verify the AcceptSession function.
460 * @tc.type: FUNC
461 * @tc.require: SR000H0387
462 */
463 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_AcceptSession_0100, TestSize.Level1)
464 {
465 GTEST_LOG_(INFO) << "SoftbusAgentTest_AcceptSession_0100 start";
466 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
467 shared_ptr<MountPoint> smp = move(mp);
468 weak_ptr<MountPoint> wmp(smp);
469 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
470 const int testSessionId = 99;
471 std::string peerDeviceId = "f6d4c0864707aefte7a78f09473aa122ff57fc8";
472 auto session = make_shared<SoftbusSession>(testSessionId, peerDeviceId);
473 bool res = true;
474 try {
475 agent->AcceptSession(session, "Server");
476 } catch (const exception &e) {
477 res = false;
478 LOGE("%{public}s", e.what());
479 }
480 EXPECT_TRUE(res);
481 GTEST_LOG_(INFO) << "SoftbusAgentTest_AcceptSession_0100 end";
482 }
483
484 /**
485 * @tc.name: SoftbusAgentTest_AcceptSession_0101
486 * @tc.desc: Verify the AcceptSession function.
487 * @tc.type: FUNC
488 * @tc.require: SR000H0387
489 */
490 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_AcceptSession_0101, TestSize.Level1)
491 {
492 GTEST_LOG_(INFO) << "SoftbusAgentTest_AcceptSession_0101 start";
493 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
494 shared_ptr<MountPoint> smp = move(mp);
495 weak_ptr<MountPoint> wmp(smp);
496 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
497 bool res = true;
498 try {
499 agent->AcceptSession(nullptr, "Server");
500 } catch (const exception &e) {
501 res = false;
502 LOGE("%{public}s", e.what());
503 }
504 EXPECT_TRUE(res);
505 GTEST_LOG_(INFO) << "SoftbusAgentTest_AcceptSession_0101 end";
506 }
507
508 /**
509 * @tc.name: SoftbusAgentTest_GetMountPoint_0100
510 * @tc.desc: Verify the GetMountPoint function.
511 * @tc.type: FUNC
512 * @tc.require: SR000H0387
513 */
514 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_GetMountPoint_0100, TestSize.Level1)
515 {
516 GTEST_LOG_(INFO) << "SoftbusAgentTest_GetMountPoint_0100 start";
517 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
518 shared_ptr<MountPoint> smp = move(mp);
519 weak_ptr<MountPoint> wmp(smp);
520 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
521 bool res = true;
522 try {
523 agent->GetMountPoint();
524 } catch (const exception &e) {
525 res = false;
526 LOGE("%{public}s", e.what());
527 }
528 EXPECT_TRUE(res);
529 GTEST_LOG_(INFO) << "SoftbusAgentTest_GetMountPoint_0100 end";
530 }
531
532 /**
533 * @tc.name: SoftbusAgentTest_CloseSession_0100
534 * @tc.desc: Verify the CloseSession function.
535 * @tc.type: FUNC
536 * @tc.require: issueI7SP3A
537 */
538 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_CloseSession_0100, TestSize.Level1)
539 {
540 GTEST_LOG_(INFO) << "SoftbusAgentTest_CloseSession_0100 start";
541 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
542 shared_ptr<MountPoint> smp = move(mp);
543 weak_ptr<MountPoint> wmp(smp);
544 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
545 try {
546 agent->CloseSession(nullptr);
547 EXPECT_TRUE(true);
548 } catch (const exception &e) {
549 LOGE("%{public}s", e.what());
550 EXPECT_TRUE(false);
551 }
552 GTEST_LOG_(INFO) << "SoftbusAgentTest_CloseSession_0100 end";
553 }
554
555 /**
556 * @tc.name: SoftbusAgentTest_IsContinueRetry_0100
557 * @tc.desc: Verify the IsContinueRetry function.
558 * @tc.type: FUNC
559 * @tc.require: issueI7SP3A
560 */
561 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_IsContinueRetry_0100, TestSize.Level1)
562 {
563 GTEST_LOG_(INFO) << "SoftbusAgentTest_IsContinueRetry_0100 start";
564 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
565 shared_ptr<MountPoint> smp = move(mp);
566 weak_ptr<MountPoint> wmp(smp);
567 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
568 string cid = "notExitCid";
569 try {
570 bool ret = agent->IsContinueRetry(cid);
571 EXPECT_EQ(agent->OpenSessionRetriedTimesMap_[cid], 1);
572 ret = agent->IsContinueRetry(cid);
573 EXPECT_EQ(ret, true);
574 agent->OpenSessionRetriedTimesMap_[cid] = MAX_RETRY_COUNT;
575 ret = agent->IsContinueRetry(cid);
576 EXPECT_EQ(ret, false);
577 } catch (const exception &e) {
578 LOGE("%{public}s", e.what());
579 EXPECT_TRUE(false);
580 }
581 GTEST_LOG_(INFO) << "SoftbusAgentTest_IsContinueRetry_0100 end";
582 }
583
584 /**
585 * @tc.name: SoftbusAgentTest_OnSessionOpened_0100
586 * @tc.desc: Verify the OnSessionOpened function.
587 * @tc.type: FUNC
588 * @tc.require: issueI7SP3A
589 */
590 HWTEST_F(SoftbusAgentTest, SoftbusAgentTest_OnSessionOpened_0100, TestSize.Level1)
591 {
592 GTEST_LOG_(INFO) << "SoftbusAgentTest_OnSessionOpened_0100 start";
593 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
594 shared_ptr<MountPoint> smp = move(mp);
595 weak_ptr<MountPoint> wmp(smp);
596 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
597 std::string sessionName = "testSession";
598 int32_t socketId = 1;
599 string cid = "notExitCid";
600 PeerSocketInfo info1 = {
601 .name = const_cast<char*>(sessionName.c_str()),
602 .networkId = const_cast<char*>(NETWORKID_ONE.c_str()),
603 };
604 agent->OnSessionOpened(socketId, info1);
605 auto ret = agent->IsContinueRetry(cid);
606 EXPECT_EQ(ret, true);
607 GTEST_LOG_(INFO) << "SoftbusAgentTest_OnSessionOpened_0100 end";
608 }
609 } // namespace Test
610 } // namespace DistributedFile
611 } // namespace Storage
612 } // namespace OHOS
613