1 /*
2 * Copyright (c) 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
16 #include "all_connect/all_connect_manager.h"
17
18 #include <memory>
19 #include <thread>
20
21 #include "dfs_error.h"
22 #include "gmock/gmock.h"
23 #include "gtest/gtest.h"
24 #include "library_func_mock.h"
25 #include "network/softbus/softbus_asset_recv_listener.h"
26 #include "network/softbus/softbus_asset_send_listener.h"
27
28 namespace OHOS {
29 namespace Storage {
30 namespace DistributedFile {
CollaborationMockFail(ServiceCollaborationManager_API * exportapi)31 int32_t CollaborationMockFail(ServiceCollaborationManager_API *exportapi)
32 {
33 return -1;
34 }
35
CollaborationMockSuccess(ServiceCollaborationManager_API * exportapi)36 int32_t CollaborationMockSuccess(ServiceCollaborationManager_API *exportapi)
37 {
38 return 0;
39 }
40
DisConnectByAllConnect(const std::string & peerNetworkId)41 void SoftbusAssetRecvListener::DisConnectByAllConnect(const std::string &peerNetworkId) {}
42
DisConnectByAllConnect(const std::string & peerNetworkId)43 void SoftBusAssetSendListener::DisConnectByAllConnect(const std::string &peerNetworkId) {}
44 namespace Test {
45 using namespace testing;
46 using namespace testing::ext;
47 using namespace OHOS::FileManagement;
48
49 class AllConnectManagerTest : public testing::Test {
50 public:
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
53 void SetUp();
54 void TearDown();
55
56 public:
57 static inline std::shared_ptr<LibraryFuncMock> libraryFuncMock_ = nullptr;
58 static inline std::string peerNetworkId = "testNetworkId";
59 };
60
SetUpTestCase(void)61 void AllConnectManagerTest::SetUpTestCase(void)
62 {
63 GTEST_LOG_(INFO) << "AllConnectManagerTest SetUpTestCase";
64 libraryFuncMock_ = std::make_shared<LibraryFuncMock>();
65 LibraryFuncMock::libraryFunc_ = libraryFuncMock_;
66 }
67
TearDownTestCase(void)68 void AllConnectManagerTest::TearDownTestCase(void)
69 {
70 GTEST_LOG_(INFO) << "AllConnectManagerTest TearDownTestCase";
71 LibraryFuncMock::libraryFunc_ = nullptr;
72 libraryFuncMock_ = nullptr;
73 }
74
SetUp(void)75 void AllConnectManagerTest::SetUp(void)
76 {
77 GTEST_LOG_(INFO) << "SetUp";
78 }
79
TearDown(void)80 void AllConnectManagerTest::TearDown(void)
81 {
82 GTEST_LOG_(INFO) << "TearDown";
83 }
84
85 /**
86 * @tc.name: AllConnectManagerTest_InitAllConnectManager_001
87 * @tc.desc: verify InitAllConnectManager GetAllConnectSoLoad fail.
88 * @tc.type: FUNC
89 * @tc.require: I7TDJK
90 */
91 HWTEST_F(AllConnectManagerTest, InitAllConnectManager_001, TestSize.Level1)
92 {
93 GTEST_LOG_(INFO) << "InitAllConnectManager_001 start";
94 try {
95 auto &allConnectManager = AllConnectManager::GetInstance();
96
97 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(nullptr));
98
99 int32_t ret = allConnectManager.InitAllConnectManager();
100 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
101 } catch (...) {
102 EXPECT_TRUE(false);
103 }
104 GTEST_LOG_(INFO) << "InitAllConnectManager_001 end";
105 }
106
107 /**
108 * @tc.name: AllConnectManagerTest_InitAllConnectManager_002
109 * @tc.desc: verify InitAllConnectManager RegisterLifecycleCallback fail.
110 * @tc.type: FUNC
111 * @tc.require: I7TDJK
112 */
113 HWTEST_F(AllConnectManagerTest, InitAllConnectManager_002, TestSize.Level1)
114 {
115 GTEST_LOG_(INFO) << "InitAllConnectManager_002 start";
116 char soPath[] = "test.so";
117 try {
118 auto &allConnectManager = AllConnectManager::GetInstance();
119
120 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
121 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
122 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _))
123 .WillOnce(Return(reinterpret_cast<void *>(&CollaborationMockSuccess)));
124 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = nullptr;
125
126 int32_t ret = allConnectManager.InitAllConnectManager();
127 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
128 } catch (...) {
129 EXPECT_TRUE(false);
130 }
131 GTEST_LOG_(INFO) << "InitAllConnectManager_002 end";
132 }
133
134 /**
135 * @tc.name: AllConnectManagerTest_InitAllConnectManager_003
136 * @tc.desc: verify InitAllConnectManager success.
137 * @tc.type: FUNC
138 * @tc.require: I7TDJK
139 */
140 HWTEST_F(AllConnectManagerTest, InitAllConnectManager_003, TestSize.Level1)
141 {
142 GTEST_LOG_(INFO) << "InitAllConnectManager_003 start";
143 char soPath[] = "test.so";
144 try {
145 auto &allConnectManager = AllConnectManager::GetInstance();
146
147 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
148 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
149 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _))
150 .WillOnce(Return(reinterpret_cast<void *>(&CollaborationMockSuccess)));
151 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = [](
152 const char *serviceName,
__anond109dc2d0102( const char *serviceName, ServiceCollaborationManager_Callback *callback) 153 ServiceCollaborationManager_Callback *callback) -> int32_t {
154 return 0;
155 };
156
157 int32_t ret = allConnectManager.InitAllConnectManager();
158 EXPECT_EQ(ret, FileManagement::ERR_OK);
159 } catch (...) {
160 EXPECT_TRUE(false);
161 }
162 GTEST_LOG_(INFO) << "InitAllConnectManager_003 end";
163 }
164
165 /**
166 * @tc.name: AllConnectManagerTest_UnInitAllConnectManager_001
167 * @tc.desc: verify UnRegisterLifecycleCallback fail, UnInitAllConnectManager succcess.
168 * @tc.type: FUNC
169 * @tc.require: I7TDJK
170 */
171 HWTEST_F(AllConnectManagerTest, UnInitAllConnectManager_001, TestSize.Level1)
172 {
173 GTEST_LOG_(INFO) << "UnInitAllConnectManager_001 start";
174 try {
175 auto &allConnectManager = AllConnectManager::GetInstance();
176
177 allConnectManager.dllHandle_ = nullptr;
178 EXPECT_CALL(*libraryFuncMock_, dlclose(_)).WillOnce(Return(0));
179 int32_t ret = allConnectManager.UnInitAllConnectManager();
180 EXPECT_EQ(ret, FileManagement::ERR_OK);
181
182 int test = 0;
183 EXPECT_CALL(*libraryFuncMock_, dlclose(_)).WillOnce(Return(0));
184 allConnectManager.dllHandle_ = &test;
__anond109dc2d0202(const char *servcieName) 185 auto tmpfunc = [](const char *servcieName) -> int32_t {
186 return FileManagement::ERR_OK;
187 };
188 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = tmpfunc;
189 ret = allConnectManager.UnInitAllConnectManager();
190 EXPECT_EQ(ret, FileManagement::ERR_OK);
191 allConnectManager.dllHandle_ = nullptr;
192 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = nullptr;
193 } catch (...) {
194 EXPECT_TRUE(false);
195 }
196 GTEST_LOG_(INFO) << "UnInitAllConnectManager_001 end";
197 }
198
199 /**
200 * @tc.name: AllConnectManagerTest_PublishServiceState_001
201 * @tc.desc: verify PublishServiceState dllHandle_ is nullptr.
202 * @tc.type: FUNC
203 * @tc.require: I7TDJK
204 */
205 HWTEST_F(AllConnectManagerTest, PublishServiceState_001, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "PublishServiceState_001 start";
208 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
209 try {
210 auto &allConnectManager = AllConnectManager::GetInstance();
211
212 allConnectManager.dllHandle_ = nullptr;
213
214 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
215 EXPECT_EQ(ret, FileManagement::ERR_OK);
216 } catch (...) {
217 EXPECT_TRUE(false);
218 }
219 GTEST_LOG_(INFO) << "PublishServiceState_001 end";
220 }
221
222 /**
223 * @tc.name: AllConnectManagerTest_PublishServiceState_002
224 * @tc.desc: verify PublishServiceState allConnect_ is nullptr.
225 * @tc.type: FUNC
226 * @tc.require: I7TDJK
227 */
228 HWTEST_F(AllConnectManagerTest, PublishServiceState_002, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "PublishServiceState_002 start";
231 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
232 try {
233 auto &allConnectManager = AllConnectManager::GetInstance();
234
235 allConnectManager.dllHandle_ = (void *)0x1;
236 allConnectManager.allConnect_.ServiceCollaborationManager_PublishServiceState = nullptr;
237
238 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
239 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
240 } catch (...) {
241 EXPECT_TRUE(false);
242 }
243 GTEST_LOG_(INFO) << "PublishServiceState_002 end";
244 }
245
246 /**
247 * @tc.name: AllConnectManagerTest_PublishServiceState_003
248 * @tc.desc: verify PublishServiceState fail.
249 * @tc.type: FUNC
250 * @tc.require: I7TDJK
251 */
252 HWTEST_F(AllConnectManagerTest, PublishServiceState_003, TestSize.Level1)
253 {
254 GTEST_LOG_(INFO) << "PublishServiceState_003 start";
255 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
256 try {
257 auto &allConnectManager = AllConnectManager::GetInstance();
258
259 allConnectManager.dllHandle_ = (void *)0x1;
260 allConnectManager.allConnect_.ServiceCollaborationManager_PublishServiceState = [](
261 const char *peerNetworkId,
262 const char *serviceName,
263 const char *extraInfo,
__anond109dc2d0302( const char *peerNetworkId, const char *serviceName, const char *extraInfo, ServiceCollaborationManagerBussinessStatus state) 264 ServiceCollaborationManagerBussinessStatus state) -> int32_t {
265 return 1;
266 };
267
268 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
269 EXPECT_EQ(ret, FileManagement::ERR_OK);
270 } catch (...) {
271 EXPECT_TRUE(false);
272 }
273 GTEST_LOG_(INFO) << "PublishServiceState_003 end";
274 }
275
276 /**
277 * @tc.name: AllConnectManagerTest_PublishServiceState_004
278 * @tc.desc: verify PublishServiceState success.
279 * @tc.type: FUNC
280 * @tc.require: I7TDJK
281 */
282 HWTEST_F(AllConnectManagerTest, PublishServiceState_004, TestSize.Level1)
283 {
284 GTEST_LOG_(INFO) << "PublishServiceState_004 start";
285 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
286 try {
287 auto &allConnectManager = AllConnectManager::GetInstance();
288
289 allConnectManager.dllHandle_ = (void *)0x1;
290 allConnectManager.allConnect_.ServiceCollaborationManager_PublishServiceState = [](
291 const char *peerNetworkId, const char *serviceName, const char *extraInfo,
__anond109dc2d0402( const char *peerNetworkId, const char *serviceName, const char *extraInfo, ServiceCollaborationManagerBussinessStatus state) 292 ServiceCollaborationManagerBussinessStatus state) -> int32_t {
293 return 0;
294 };
295
296 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
297 EXPECT_EQ(ret, FileManagement::ERR_OK);
298
299 state = ServiceCollaborationManagerBussinessStatus::SCM_CONNECTED;
300 ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
301 EXPECT_EQ(ret, FileManagement::ERR_OK);
302
303 allConnectManager.connectStates_.clear();
304 allConnectManager.allConnect_.ServiceCollaborationManager_PublishServiceState = [](
305 const char *peerNetworkId, const char *serviceName, const char *extraInfo,
__anond109dc2d0502( const char *peerNetworkId, const char *serviceName, const char *extraInfo, ServiceCollaborationManagerBussinessStatus state) 306 ServiceCollaborationManagerBussinessStatus state) -> int32_t {
307 return FileManagement::ERR_PUBLISH_STATE;
308 };
309 ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
310 EXPECT_EQ(ret, FileManagement::ERR_PUBLISH_STATE);
311 } catch (...) {
312 EXPECT_TRUE(false);
313 }
314 GTEST_LOG_(INFO) << "PublishServiceState_004 end";
315 }
316
317 /**
318 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_001
319 * @tc.desc: verify ApplyAdvancedResource dllHandle_ is nullptr.
320 * @tc.type: FUNC
321 * @tc.require: I7TDJK
322 */
323 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_001, TestSize.Level1)
324 {
325 GTEST_LOG_(INFO) << "ApplyAdvancedResource_001 start";
326 try {
327 auto &allConnectManager = AllConnectManager::GetInstance();
328
329 allConnectManager.dllHandle_ = nullptr;
330
331 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
332 EXPECT_EQ(ret, FileManagement::ERR_OK);
333 } catch (...) {
334 EXPECT_TRUE(false);
335 }
336 GTEST_LOG_(INFO) << "ApplyAdvancedResource_001 end";
337 }
338
339 /**
340 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_002
341 * @tc.desc: verify ApplyAdvancedResource allConnect_ is nullptr.
342 * @tc.type: FUNC
343 * @tc.require: I7TDJK
344 */
345 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_002, TestSize.Level1)
346 {
347 GTEST_LOG_(INFO) << "ApplyAdvancedResource_002 start";
348 try {
349 auto &allConnectManager = AllConnectManager::GetInstance();
350
351 allConnectManager.dllHandle_ = (void *)0x1;
352 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = nullptr;
353
354 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
355 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
356 } catch (...) {
357 EXPECT_TRUE(false);
358 }
359 GTEST_LOG_(INFO) << "ApplyAdvancedResource_002 end";
360 }
361
362 /**
363 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_003
364 * @tc.desc: verify ApplyAdvancedResource fail.
365 * @tc.type: FUNC
366 * @tc.require: I7TDJK
367 */
368 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_003, TestSize.Level1)
369 {
370 GTEST_LOG_(INFO) << "ApplyAdvancedResource_003 start";
371 try {
372 auto &allConnectManager = AllConnectManager::GetInstance();
373
374 allConnectManager.dllHandle_ = (void *)0x1;
375 allConnectManager.applyResultBlock_ = nullptr;
376 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = [](
377 const char *peerNetworkId,
378 const char *serviceName,
379 ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest,
__anond109dc2d0602( const char *peerNetworkId, const char *serviceName, ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest, ServiceCollaborationManager_Callback *callback) 380 ServiceCollaborationManager_Callback *callback) -> int32_t {
381 return 1;
382 };
383
384 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
385 EXPECT_EQ(ret, FileManagement::ERR_APPLY_RESULT);
386 } catch (...) {
387 EXPECT_TRUE(false);
388 }
389 GTEST_LOG_(INFO) << "ApplyAdvancedResource_003 end";
390 }
391
392 /**
393 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_004
394 * @tc.desc: verify ApplyAdvancedResource fail.
395 * @tc.type: FUNC
396 * @tc.require: I7TDJK
397 */
398 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_004, TestSize.Level1)
399 {
400 GTEST_LOG_(INFO) << "ApplyAdvancedResource_004 start";
401 try {
402 auto &allConnectManager = AllConnectManager::GetInstance();
403
404 allConnectManager.dllHandle_ = (void *)0x1;
405 allConnectManager.applyResultBlock_ = nullptr;
406 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = [](
407 const char *peerNetworkId,
408 const char *serviceName,
409 ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest,
__anond109dc2d0702( const char *peerNetworkId, const char *serviceName, ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest, ServiceCollaborationManager_Callback *callback) 410 ServiceCollaborationManager_Callback *callback) -> int32_t {
411 return 0;
412 };
__anond109dc2d0802() 413 std::thread([&allConnectManager]() {
414 int32_t num = 10;
415 while (allConnectManager.applyResultBlock_ == nullptr && num-- > 0) {
416 std::this_thread::sleep_for(std::chrono::seconds(1));
417 }
418 if (allConnectManager.applyResultBlock_ == nullptr) {
419 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
420 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
421 }
422 allConnectManager.applyResultBlock_->SetValue(false);
423 }).detach();
424
425 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
426 EXPECT_EQ(ret, FileManagement::ERR_APPLY_RESULT);
427 } catch (...) {
428 EXPECT_TRUE(false);
429 }
430 GTEST_LOG_(INFO) << "ApplyAdvancedResource_004 end";
431 }
432
433 /**
434 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_005
435 * @tc.desc: verify ApplyAdvancedResource success.
436 * @tc.type: FUNC
437 * @tc.require: I7TDJK
438 */
439 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_005, TestSize.Level1)
440 {
441 GTEST_LOG_(INFO) << "ApplyAdvancedResource_005 start";
442 try {
443 auto &allConnectManager = AllConnectManager::GetInstance();
444
445 allConnectManager.dllHandle_ = (void *)0x1;
446 allConnectManager.applyResultBlock_ = nullptr;
447 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = [](
448 const char *peerNetworkId,
449 const char *serviceName,
450 ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest,
__anond109dc2d0902( const char *peerNetworkId, const char *serviceName, ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest, ServiceCollaborationManager_Callback *callback) 451 ServiceCollaborationManager_Callback *callback) -> int32_t {
452 return 0;
453 };
__anond109dc2d0a02() 454 std::thread([&allConnectManager]() {
455 int32_t num = 10;
456 while (allConnectManager.applyResultBlock_ == nullptr && num-- > 0) {
457 std::this_thread::sleep_for(std::chrono::seconds(1));
458 }
459 if (allConnectManager.applyResultBlock_ == nullptr) {
460 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
461 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
462 }
463 allConnectManager.applyResultBlock_->SetValue(true);
464 }).detach();
465
466 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
467 EXPECT_EQ(ret, FileManagement::ERR_OK);
468 } catch (...) {
469 EXPECT_TRUE(false);
470 }
471 GTEST_LOG_(INFO) << "ApplyAdvancedResource_005 end";
472 }
473
474 /**
475 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_001
476 * @tc.desc: verify GetAllConnectSoLoad fail.
477 * @tc.type: FUNC
478 * @tc.require: I7TDJK
479 */
480 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_001, TestSize.Level1)
481 {
482 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_001 start";
483 try {
484 auto &allConnectManager = AllConnectManager::GetInstance();
485
486 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(nullptr));
487
488 int32_t ret = allConnectManager.GetAllConnectSoLoad();
489 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
490 } catch (...) {
491 EXPECT_TRUE(false);
492 }
493 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_001 end";
494 }
495
496 /**
497 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_002
498 * @tc.desc: verify GetAllConnectSoLoad fail.
499 * @tc.type: FUNC
500 * @tc.require: I7TDJK
501 */
502 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_002, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_002 start";
505 char soPath[] = "test.so";
506 try {
507 auto &allConnectManager = AllConnectManager::GetInstance();
508
509 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
510 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x0)));
511
512 int32_t ret = allConnectManager.GetAllConnectSoLoad();
513 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
514 } catch (...) {
515 EXPECT_TRUE(false);
516 }
517 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_002 end";
518 }
519
520 /**
521 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_003
522 * @tc.desc: verify GetAllConnectSoLoad fail.
523 * @tc.type: FUNC
524 * @tc.require: I7TDJK
525 */
526 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_003, TestSize.Level1)
527 {
528 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_003 start";
529 char soPath[] = "test.so";
530 try {
531 auto &allConnectManager = AllConnectManager::GetInstance();
532
533 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
534 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
535 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _)).WillOnce(Return(nullptr));
536 EXPECT_CALL(*libraryFuncMock_, dlclose(_)).WillOnce(Return(0));
537
538 int32_t ret = allConnectManager.GetAllConnectSoLoad();
539 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
540 } catch (...) {
541 EXPECT_TRUE(false);
542 }
543 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_003 end";
544 }
545
546 /**
547 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_004
548 * @tc.desc: verify GetAllConnectSoLoad fail.
549 * @tc.type: FUNC
550 * @tc.require: I7TDJK
551 */
552 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_004, TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_004 start";
555 char soPath[] = "test.so";
556 try {
557 auto &allConnectManager = AllConnectManager::GetInstance();
558
559 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
560 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
561 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _))
562 .WillOnce(Return(reinterpret_cast<void *>(&CollaborationMockFail)));
563 EXPECT_CALL(*libraryFuncMock_, dlclose(_)).WillOnce(Return(0));
564
565 int32_t ret = allConnectManager.GetAllConnectSoLoad();
566 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
567 } catch (...) {
568 EXPECT_TRUE(false);
569 }
570 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_004 end";
571 }
572
573 /**
574 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_005
575 * @tc.desc: verify GetAllConnectSoLoad success.
576 * @tc.type: FUNC
577 * @tc.require: I7TDJK
578 */
579 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_005, TestSize.Level1)
580 {
581 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_005 start";
582 char soPath[] = "test.so";
583 try {
584 auto &allConnectManager = AllConnectManager::GetInstance();
585
586 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
587 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
588 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _))
589 .WillOnce(Return(reinterpret_cast<void *>(&CollaborationMockSuccess)));
590
591 int32_t ret = allConnectManager.GetAllConnectSoLoad();
592 EXPECT_EQ(ret, FileManagement::ERR_OK);
593 } catch (...) {
594 EXPECT_TRUE(false);
595 }
596 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_005 end";
597 }
598
599 /**
600 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_001
601 * @tc.desc: verify RegisterLifecycleCallback dllHandle_ is nullptr.
602 * @tc.type: FUNC
603 * @tc.require: I7TDJK
604 */
605 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_001, TestSize.Level1)
606 {
607 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_001 start";
608 try {
609 auto &allConnectManager = AllConnectManager::GetInstance();
610
611 allConnectManager.dllHandle_ = nullptr;
612
613 int32_t ret = allConnectManager.RegisterLifecycleCallback();
614 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
615 } catch (...) {
616 EXPECT_TRUE(false);
617 }
618 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_001 end";
619 }
620
621 /**
622 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_002
623 * @tc.desc: verify RegisterLifecycleCallback allConnect_ is nullptr.
624 * @tc.type: FUNC
625 * @tc.require: I7TDJK
626 */
627 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_002, TestSize.Level1)
628 {
629 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_002 start";
630 try {
631 auto &allConnectManager = AllConnectManager::GetInstance();
632
633 allConnectManager.dllHandle_ = (void *)0x1;
634 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = nullptr;
635
636 int32_t ret = allConnectManager.RegisterLifecycleCallback();
637 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
638 } catch (...) {
639 EXPECT_TRUE(false);
640 }
641 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_002 end";
642 }
643
644 /**
645 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_003
646 * @tc.desc: verify RegisterLifecycleCallback fail.
647 * @tc.type: FUNC
648 * @tc.require: I7TDJK
649 */
650 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_003, TestSize.Level1)
651 {
652 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_003 start";
653 try {
654 auto &allConnectManager = AllConnectManager::GetInstance();
655
656 allConnectManager.dllHandle_ = (void *)0x1;
657 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = [](
658 const char *serviceName,
__anond109dc2d0b02( const char *serviceName, ServiceCollaborationManager_Callback *callback) 659 ServiceCollaborationManager_Callback *callback) -> int32_t {
660 return 1;
661 };
662
663 int32_t ret = allConnectManager.RegisterLifecycleCallback();
664 EXPECT_EQ(ret, FileManagement::ERR_ALLCONNECT);
665 } catch (...) {
666 EXPECT_TRUE(false);
667 }
668 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_003 end";
669 }
670
671 /**
672 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_004
673 * @tc.desc: verify RegisterLifecycleCallback success.
674 * @tc.type: FUNC
675 * @tc.require: I7TDJK
676 */
677 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_004, TestSize.Level1)
678 {
679 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_004 start";
680 try {
681 auto &allConnectManager = AllConnectManager::GetInstance();
682
683 allConnectManager.dllHandle_ = (void *)0x1;
684 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = [](
685 const char *serviceName,
__anond109dc2d0c02( const char *serviceName, ServiceCollaborationManager_Callback *callback) 686 ServiceCollaborationManager_Callback *callback) -> int32_t {
687 return 0;
688 };
689
690 int32_t ret = allConnectManager.RegisterLifecycleCallback();
691 EXPECT_EQ(ret, FileManagement::ERR_OK);
692 } catch (...) {
693 EXPECT_TRUE(false);
694 }
695 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_004 end";
696 }
697
698 /**
699 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_001
700 * @tc.desc: verify UnRegisterLifecycleCallback dllHandle_ is nullptr.
701 * @tc.type: FUNC
702 * @tc.require: I7TDJK
703 */
704 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_001, TestSize.Level1)
705 {
706 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_001 start";
707 try {
708 auto &allConnectManager = AllConnectManager::GetInstance();
709
710 allConnectManager.dllHandle_ = nullptr;
711
712 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
713 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
714 } catch (...) {
715 EXPECT_TRUE(false);
716 }
717 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_001 end";
718 }
719
720 /**
721 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_002
722 * @tc.desc: verify UnRegisterLifecycleCallback allConnect_ is nullptr.
723 * @tc.type: FUNC
724 * @tc.require: I7TDJK
725 */
726 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_002, TestSize.Level1)
727 {
728 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_002 start";
729 try {
730 auto &allConnectManager = AllConnectManager::GetInstance();
731
732 allConnectManager.dllHandle_ = (void *)0x1;
733 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = nullptr;
734
735 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
736 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
737 } catch (...) {
738 EXPECT_TRUE(false);
739 }
740 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_002 end";
741 }
742
743 /**
744 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_003
745 * @tc.desc: verify UnRegisterLifecycleCallback fail.
746 * @tc.type: FUNC
747 * @tc.require: I7TDJK
748 */
749 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_003, TestSize.Level1)
750 {
751 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_003 start";
752 try {
753 auto &allConnectManager = AllConnectManager::GetInstance();
754
755 allConnectManager.dllHandle_ = (void *)0x1;
756 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = [](
__anond109dc2d0d02( const char *serviceName) 757 const char *serviceName) -> int32_t {
758 return 1;
759 };
760
761 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
762 EXPECT_EQ(ret, FileManagement::ERR_ALLCONNECT);
763 } catch (...) {
764 EXPECT_TRUE(false);
765 }
766 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_003 end";
767 }
768
769 /**
770 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_004
771 * @tc.desc: verify UnRegisterLifecycleCallback success.
772 * @tc.type: FUNC
773 * @tc.require: I7TDJK
774 */
775 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_004, TestSize.Level1)
776 {
777 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_004 start";
778 try {
779 auto &allConnectManager = AllConnectManager::GetInstance();
780
781 allConnectManager.dllHandle_ = (void *)0x1;
782 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = [](
__anond109dc2d0e02( const char *serviceName) 783 const char *serviceName) -> int32_t {
784 return 0;
785 };
786
787 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
788 EXPECT_EQ(ret, FileManagement::ERR_OK);
789 } catch (...) {
790 EXPECT_TRUE(false);
791 }
792 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_004 end";
793 }
794
795 /**
796 * @tc.name: AllConnectManagerTest_OnStop_001
797 * @tc.desc: verify OnStop.
798 * @tc.type: FUNC
799 * @tc.require: I7TDJK
800 */
801 HWTEST_F(AllConnectManagerTest, OnStop_001, TestSize.Level1)
802 {
803 GTEST_LOG_(INFO) << "OnStop_001 start";
804 try {
805 auto &allConnectManager = AllConnectManager::GetInstance();
806
807 int32_t ret = allConnectManager.OnStop("");
808 EXPECT_EQ(ret, FileManagement::ERR_OK);
809 } catch (...) {
810 EXPECT_TRUE(false);
811 }
812 GTEST_LOG_(INFO) << "OnStop_001 end";
813 }
814
815 /**
816 * @tc.name: AllConnectManagerTest_ApplyResult_001
817 * @tc.desc: verify ApplyResult result is REJECT.
818 * @tc.type: FUNC
819 * @tc.require: I7TDJK
820 */
821 HWTEST_F(AllConnectManagerTest, ApplyResult_001, TestSize.Level1)
822 {
823 GTEST_LOG_(INFO) << "ApplyResult_001 start";
824 try {
825 auto &allConnectManager = AllConnectManager::GetInstance();
826
827 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
828 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
829
830 int32_t ret = allConnectManager.ApplyResult(0, REJECT, "");
831 EXPECT_EQ(ret, FileManagement::ERR_APPLY_RESULT);
832 EXPECT_EQ(allConnectManager.applyResultBlock_ -> GetValue(), false);
833 } catch (...) {
834 EXPECT_TRUE(false);
835 }
836 GTEST_LOG_(INFO) << "ApplyResult_001 end";
837 }
838
839 /**
840 * @tc.name: AllConnectManagerTest_ApplyResult_002
841 * @tc.desc: verify ApplyResult result is PASS.
842 * @tc.type: FUNC
843 * @tc.require: I7TDJK
844 */
845 HWTEST_F(AllConnectManagerTest, ApplyResult_002, TestSize.Level1)
846 {
847 GTEST_LOG_(INFO) << "ApplyResult_002 start";
848 try {
849 auto &allConnectManager = AllConnectManager::GetInstance();
850
851 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
852 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
853
854 int32_t ret = allConnectManager.ApplyResult(0, PASS, "");
855 EXPECT_EQ(ret, FileManagement::ERR_OK);
856 EXPECT_EQ(allConnectManager.applyResultBlock_->GetValue(), true);
857 } catch (...) {
858 EXPECT_TRUE(false);
859 }
860 GTEST_LOG_(INFO) << "ApplyResult_002 end";
861 }
862
863 /**
864 * @tc.name: AllConnectManagerTest_BuildResourceRequest_001
865 * @tc.desc: verify BuildResourceRequest.
866 * @tc.type: FUNC
867 * @tc.require: I7TDJK
868 */
869 HWTEST_F(AllConnectManagerTest, BuildResourceRequest_001, TestSize.Level1)
870 {
871 GTEST_LOG_(INFO) << "BuildResourceRequest_001 start";
872 try {
873 auto &allConnectManager = AllConnectManager::GetInstance();
874 auto ret = allConnectManager.BuildResourceRequest();
875 EXPECT_TRUE(ret != nullptr);
876
877 ret = allConnectManager.BuildResourceRequest();
878 EXPECT_TRUE(ret != nullptr);
879 } catch (...) {
880 EXPECT_TRUE(false);
881 }
882 GTEST_LOG_(INFO) << "BuildResourceRequest_001 end";
883 }
884
885 /**
886 * @tc.name: AllConnectManagerTest_GetPublicState_001
887 * @tc.desc: verify GetPublicState.
888 * @tc.type: FUNC
889 * @tc.require: I7TDJK
890 */
891 HWTEST_F(AllConnectManagerTest, GetPublicState_001, TestSize.Level1)
892 {
893 GTEST_LOG_(INFO) << "GetPublicState_001 start";
894 try {
895 auto &allConnectManager = AllConnectManager::GetInstance();
896 auto state = ServiceCollaborationManagerBussinessStatus::SCM_CONNECTED;
897 allConnectManager.connectStates_.clear();
898 allConnectManager.connectStates_.emplace(peerNetworkId,
899 std::map<DfsConnectCode, ServiceCollaborationManagerBussinessStatus>{{DfsConnectCode::OPEN_P2P, state}});
900 auto ret = allConnectManager.GetPublicState(DfsConnectCode::PUSH_ASSET, peerNetworkId, state);
901 EXPECT_TRUE(ret);
902
903 state = ServiceCollaborationManagerBussinessStatus::SCM_CONNECTING;
904 allConnectManager.connectStates_[peerNetworkId].erase(DfsConnectCode::PUSH_ASSET);
905 ret = allConnectManager.GetPublicState(DfsConnectCode::PUSH_ASSET, peerNetworkId, state);
906 EXPECT_TRUE(!ret);
907 allConnectManager.connectStates_[peerNetworkId].erase(DfsConnectCode::PUSH_ASSET);
908 ret = allConnectManager.GetPublicState(DfsConnectCode::OPEN_P2P, peerNetworkId, state);
909 EXPECT_TRUE(ret);
910
911 state = ServiceCollaborationManagerBussinessStatus::SCM_CONNECTED;
912 allConnectManager.connectStates_[peerNetworkId][DfsConnectCode::OPEN_P2P] = state;
913 state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
914 ret = allConnectManager.GetPublicState(DfsConnectCode::OPEN_P2P, peerNetworkId, state);
915 EXPECT_TRUE(ret);
916
917 state = ServiceCollaborationManagerBussinessStatus::SCM_CONNECTED;
918 allConnectManager.connectStates_[peerNetworkId].emplace(DfsConnectCode::PUSH_ASSET, state);
919 allConnectManager.connectStates_[peerNetworkId][DfsConnectCode::OPEN_P2P] = state;
920 state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
921 ret = allConnectManager.GetPublicState(DfsConnectCode::PUSH_ASSET, peerNetworkId, state);
922 EXPECT_TRUE(!ret);
923 } catch (...) {
924 EXPECT_TRUE(false);
925 }
926 GTEST_LOG_(INFO) << "GetPublicState_001 end";
927 }
928 }
929 } // namespace DistributedFile
930 } // namespace Storage
931 } // namespace OHOS
932