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,
__anond781708b0102( 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
180
181 int32_t ret = allConnectManager.UnInitAllConnectManager();
182 EXPECT_EQ(ret, FileManagement::ERR_OK);
183 } catch (...) {
184 EXPECT_TRUE(false);
185 }
186 GTEST_LOG_(INFO) << "UnInitAllConnectManager_001 end";
187 }
188
189 /**
190 * @tc.name: AllConnectManagerTest_PublishServiceState_001
191 * @tc.desc: verify PublishServiceState dllHandle_ is nullptr.
192 * @tc.type: FUNC
193 * @tc.require: I7TDJK
194 */
195 HWTEST_F(AllConnectManagerTest, PublishServiceState_001, TestSize.Level1)
196 {
197 GTEST_LOG_(INFO) << "PublishServiceState_001 start";
198 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
199 try {
200 auto &allConnectManager = AllConnectManager::GetInstance();
201
202 allConnectManager.dllHandle_ = nullptr;
203
204 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
205 EXPECT_EQ(ret, FileManagement::ERR_OK);
206 } catch (...) {
207 EXPECT_TRUE(false);
208 }
209 GTEST_LOG_(INFO) << "PublishServiceState_001 end";
210 }
211
212 /**
213 * @tc.name: AllConnectManagerTest_PublishServiceState_002
214 * @tc.desc: verify PublishServiceState allConnect_ is nullptr.
215 * @tc.type: FUNC
216 * @tc.require: I7TDJK
217 */
218 HWTEST_F(AllConnectManagerTest, PublishServiceState_002, TestSize.Level1)
219 {
220 GTEST_LOG_(INFO) << "PublishServiceState_002 start";
221 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
222 try {
223 auto &allConnectManager = AllConnectManager::GetInstance();
224
225 allConnectManager.dllHandle_ = (void *)0x1;
226 allConnectManager.allConnect_.ServiceCollaborationManager_PublishServiceState = nullptr;
227
228 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
229 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
230 } catch (...) {
231 EXPECT_TRUE(false);
232 }
233 GTEST_LOG_(INFO) << "PublishServiceState_002 end";
234 }
235
236 /**
237 * @tc.name: AllConnectManagerTest_PublishServiceState_003
238 * @tc.desc: verify PublishServiceState fail.
239 * @tc.type: FUNC
240 * @tc.require: I7TDJK
241 */
242 HWTEST_F(AllConnectManagerTest, PublishServiceState_003, TestSize.Level1)
243 {
244 GTEST_LOG_(INFO) << "PublishServiceState_003 start";
245 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
246 try {
247 auto &allConnectManager = AllConnectManager::GetInstance();
248
249 allConnectManager.dllHandle_ = (void *)0x1;
250 allConnectManager.allConnect_.ServiceCollaborationManager_PublishServiceState = [](
251 const char *peerNetworkId,
252 const char *serviceName,
253 const char *extraInfo,
__anond781708b0202( const char *peerNetworkId, const char *serviceName, const char *extraInfo, ServiceCollaborationManagerBussinessStatus state) 254 ServiceCollaborationManagerBussinessStatus state) -> int32_t {
255 return 1;
256 };
257
258 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
259 EXPECT_EQ(ret, FileManagement::ERR_OK);
260 } catch (...) {
261 EXPECT_TRUE(false);
262 }
263 GTEST_LOG_(INFO) << "PublishServiceState_003 end";
264 }
265
266 /**
267 * @tc.name: AllConnectManagerTest_PublishServiceState_004
268 * @tc.desc: verify PublishServiceState success.
269 * @tc.type: FUNC
270 * @tc.require: I7TDJK
271 */
272 HWTEST_F(AllConnectManagerTest, PublishServiceState_004, TestSize.Level1)
273 {
274 GTEST_LOG_(INFO) << "PublishServiceState_004 start";
275 ServiceCollaborationManagerBussinessStatus state = ServiceCollaborationManagerBussinessStatus::SCM_IDLE;
276 try {
277 auto &allConnectManager = AllConnectManager::GetInstance();
278
279 allConnectManager.dllHandle_ = (void *)0x1;
280 allConnectManager.allConnect_.ServiceCollaborationManager_PublishServiceState = [](
281 const char *peerNetworkId,
282 const char *serviceName,
283 const char *extraInfo,
__anond781708b0302( const char *peerNetworkId, const char *serviceName, const char *extraInfo, ServiceCollaborationManagerBussinessStatus state) 284 ServiceCollaborationManagerBussinessStatus state) -> int32_t {
285 return 0;
286 };
287
288 int32_t ret = allConnectManager.PublishServiceState(DfsConnectCode::COPY_FILE, peerNetworkId, state);
289 EXPECT_EQ(ret, FileManagement::ERR_OK);
290 } catch (...) {
291 EXPECT_TRUE(false);
292 }
293 GTEST_LOG_(INFO) << "PublishServiceState_004 end";
294 }
295
296 /**
297 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_001
298 * @tc.desc: verify ApplyAdvancedResource dllHandle_ is nullptr.
299 * @tc.type: FUNC
300 * @tc.require: I7TDJK
301 */
302 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_001, TestSize.Level1)
303 {
304 GTEST_LOG_(INFO) << "ApplyAdvancedResource_001 start";
305 try {
306 auto &allConnectManager = AllConnectManager::GetInstance();
307
308 allConnectManager.dllHandle_ = nullptr;
309
310 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
311 EXPECT_EQ(ret, FileManagement::ERR_OK);
312 } catch (...) {
313 EXPECT_TRUE(false);
314 }
315 GTEST_LOG_(INFO) << "ApplyAdvancedResource_001 end";
316 }
317
318 /**
319 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_002
320 * @tc.desc: verify ApplyAdvancedResource allConnect_ is nullptr.
321 * @tc.type: FUNC
322 * @tc.require: I7TDJK
323 */
324 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_002, TestSize.Level1)
325 {
326 GTEST_LOG_(INFO) << "ApplyAdvancedResource_002 start";
327 try {
328 auto &allConnectManager = AllConnectManager::GetInstance();
329
330 allConnectManager.dllHandle_ = (void *)0x1;
331 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = nullptr;
332
333 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
334 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
335 } catch (...) {
336 EXPECT_TRUE(false);
337 }
338 GTEST_LOG_(INFO) << "ApplyAdvancedResource_002 end";
339 }
340
341 /**
342 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_003
343 * @tc.desc: verify ApplyAdvancedResource fail.
344 * @tc.type: FUNC
345 * @tc.require: I7TDJK
346 */
347 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_003, TestSize.Level1)
348 {
349 GTEST_LOG_(INFO) << "ApplyAdvancedResource_003 start";
350 try {
351 auto &allConnectManager = AllConnectManager::GetInstance();
352
353 allConnectManager.dllHandle_ = (void *)0x1;
354 allConnectManager.applyResultBlock_ = nullptr;
355 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = [](
356 const char *peerNetworkId,
357 const char *serviceName,
358 ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest,
__anond781708b0402( const char *peerNetworkId, const char *serviceName, ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest, ServiceCollaborationManager_Callback *callback) 359 ServiceCollaborationManager_Callback *callback) -> int32_t {
360 return 1;
361 };
362
363 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
364 EXPECT_EQ(ret, FileManagement::ERR_APPLY_RESULT);
365 } catch (...) {
366 EXPECT_TRUE(false);
367 }
368 GTEST_LOG_(INFO) << "ApplyAdvancedResource_003 end";
369 }
370
371 /**
372 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_004
373 * @tc.desc: verify ApplyAdvancedResource fail.
374 * @tc.type: FUNC
375 * @tc.require: I7TDJK
376 */
377 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_004, TestSize.Level1)
378 {
379 GTEST_LOG_(INFO) << "ApplyAdvancedResource_004 start";
380 try {
381 auto &allConnectManager = AllConnectManager::GetInstance();
382
383 allConnectManager.dllHandle_ = (void *)0x1;
384 allConnectManager.applyResultBlock_ = nullptr;
385 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = [](
386 const char *peerNetworkId,
387 const char *serviceName,
388 ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest,
__anond781708b0502( const char *peerNetworkId, const char *serviceName, ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest, ServiceCollaborationManager_Callback *callback) 389 ServiceCollaborationManager_Callback *callback) -> int32_t {
390 return 0;
391 };
__anond781708b0602() 392 std::thread([&allConnectManager]() {
393 int32_t num = 10;
394 while (allConnectManager.applyResultBlock_ == nullptr && num-- > 0) {
395 std::this_thread::sleep_for(std::chrono::seconds(1));
396 }
397 if (allConnectManager.applyResultBlock_ == nullptr) {
398 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
399 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
400 }
401 allConnectManager.applyResultBlock_->SetValue(false);
402 }).detach();
403
404 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
405 EXPECT_EQ(ret, FileManagement::ERR_APPLY_RESULT);
406 } catch (...) {
407 EXPECT_TRUE(false);
408 }
409 GTEST_LOG_(INFO) << "ApplyAdvancedResource_004 end";
410 }
411
412 /**
413 * @tc.name: AllConnectManagerTest_ApplyAdvancedResource_005
414 * @tc.desc: verify ApplyAdvancedResource success.
415 * @tc.type: FUNC
416 * @tc.require: I7TDJK
417 */
418 HWTEST_F(AllConnectManagerTest, ApplyAdvancedResource_005, TestSize.Level1)
419 {
420 GTEST_LOG_(INFO) << "ApplyAdvancedResource_005 start";
421 try {
422 auto &allConnectManager = AllConnectManager::GetInstance();
423
424 allConnectManager.dllHandle_ = (void *)0x1;
425 allConnectManager.applyResultBlock_ = nullptr;
426 allConnectManager.allConnect_.ServiceCollaborationManager_ApplyAdvancedResource = [](
427 const char *peerNetworkId,
428 const char *serviceName,
429 ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest,
__anond781708b0702( const char *peerNetworkId, const char *serviceName, ServiceCollaborationManager_ResourceRequestInfoSets *resourceRequest, ServiceCollaborationManager_Callback *callback) 430 ServiceCollaborationManager_Callback *callback) -> int32_t {
431 return 0;
432 };
__anond781708b0802() 433 std::thread([&allConnectManager]() {
434 int32_t num = 10;
435 while (allConnectManager.applyResultBlock_ == nullptr && num-- > 0) {
436 std::this_thread::sleep_for(std::chrono::seconds(1));
437 }
438 if (allConnectManager.applyResultBlock_ == nullptr) {
439 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
440 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
441 }
442 allConnectManager.applyResultBlock_->SetValue(true);
443 }).detach();
444
445 int32_t ret = allConnectManager.ApplyAdvancedResource(peerNetworkId, nullptr);
446 EXPECT_EQ(ret, FileManagement::ERR_OK);
447 } catch (...) {
448 EXPECT_TRUE(false);
449 }
450 GTEST_LOG_(INFO) << "ApplyAdvancedResource_005 end";
451 }
452
453 /**
454 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_001
455 * @tc.desc: verify GetAllConnectSoLoad fail.
456 * @tc.type: FUNC
457 * @tc.require: I7TDJK
458 */
459 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_001, TestSize.Level1)
460 {
461 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_001 start";
462 try {
463 auto &allConnectManager = AllConnectManager::GetInstance();
464
465 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(nullptr));
466
467 int32_t ret = allConnectManager.GetAllConnectSoLoad();
468 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
469 } catch (...) {
470 EXPECT_TRUE(false);
471 }
472 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_001 end";
473 }
474
475 /**
476 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_002
477 * @tc.desc: verify GetAllConnectSoLoad fail.
478 * @tc.type: FUNC
479 * @tc.require: I7TDJK
480 */
481 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_002, TestSize.Level1)
482 {
483 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_002 start";
484 char soPath[] = "test.so";
485 try {
486 auto &allConnectManager = AllConnectManager::GetInstance();
487
488 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
489 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x0)));
490
491 int32_t ret = allConnectManager.GetAllConnectSoLoad();
492 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
493 } catch (...) {
494 EXPECT_TRUE(false);
495 }
496 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_002 end";
497 }
498
499 /**
500 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_003
501 * @tc.desc: verify GetAllConnectSoLoad fail.
502 * @tc.type: FUNC
503 * @tc.require: I7TDJK
504 */
505 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_003, TestSize.Level1)
506 {
507 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_003 start";
508 char soPath[] = "test.so";
509 try {
510 auto &allConnectManager = AllConnectManager::GetInstance();
511
512 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
513 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
514 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _)).WillOnce(Return(nullptr));
515 EXPECT_CALL(*libraryFuncMock_, dlclose(_)).WillOnce(Return(0));
516
517 int32_t ret = allConnectManager.GetAllConnectSoLoad();
518 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
519 } catch (...) {
520 EXPECT_TRUE(false);
521 }
522 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_003 end";
523 }
524
525 /**
526 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_004
527 * @tc.desc: verify GetAllConnectSoLoad fail.
528 * @tc.type: FUNC
529 * @tc.require: I7TDJK
530 */
531 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_004, TestSize.Level1)
532 {
533 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_004 start";
534 char soPath[] = "test.so";
535 try {
536 auto &allConnectManager = AllConnectManager::GetInstance();
537
538 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
539 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
540 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _))
541 .WillOnce(Return(reinterpret_cast<void *>(&CollaborationMockFail)));
542 EXPECT_CALL(*libraryFuncMock_, dlclose(_)).WillOnce(Return(0));
543
544 int32_t ret = allConnectManager.GetAllConnectSoLoad();
545 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
546 } catch (...) {
547 EXPECT_TRUE(false);
548 }
549 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_004 end";
550 }
551
552 /**
553 * @tc.name: AllConnectManagerTest_GetAllConnectSoLoad_005
554 * @tc.desc: verify GetAllConnectSoLoad success.
555 * @tc.type: FUNC
556 * @tc.require: I7TDJK
557 */
558 HWTEST_F(AllConnectManagerTest, GetAllConnectSoLoad_005, TestSize.Level1)
559 {
560 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_005 start";
561 char soPath[] = "test.so";
562 try {
563 auto &allConnectManager = AllConnectManager::GetInstance();
564
565 EXPECT_CALL(*libraryFuncMock_, realpath(_, _)).WillOnce(Return(soPath));
566 EXPECT_CALL(*libraryFuncMock_, dlopen(_, _)).WillOnce(Return(reinterpret_cast<void *>(0x1)));
567 EXPECT_CALL(*libraryFuncMock_, dlsym(_, _))
568 .WillOnce(Return(reinterpret_cast<void *>(&CollaborationMockSuccess)));
569
570 int32_t ret = allConnectManager.GetAllConnectSoLoad();
571 EXPECT_EQ(ret, FileManagement::ERR_OK);
572 } catch (...) {
573 EXPECT_TRUE(false);
574 }
575 GTEST_LOG_(INFO) << "GetAllConnectSoLoad_005 end";
576 }
577
578 /**
579 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_001
580 * @tc.desc: verify RegisterLifecycleCallback dllHandle_ is nullptr.
581 * @tc.type: FUNC
582 * @tc.require: I7TDJK
583 */
584 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_001, TestSize.Level1)
585 {
586 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_001 start";
587 try {
588 auto &allConnectManager = AllConnectManager::GetInstance();
589
590 allConnectManager.dllHandle_ = nullptr;
591
592 int32_t ret = allConnectManager.RegisterLifecycleCallback();
593 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
594 } catch (...) {
595 EXPECT_TRUE(false);
596 }
597 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_001 end";
598 }
599
600 /**
601 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_002
602 * @tc.desc: verify RegisterLifecycleCallback allConnect_ is nullptr.
603 * @tc.type: FUNC
604 * @tc.require: I7TDJK
605 */
606 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_002, TestSize.Level1)
607 {
608 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_002 start";
609 try {
610 auto &allConnectManager = AllConnectManager::GetInstance();
611
612 allConnectManager.dllHandle_ = (void *)0x1;
613 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = nullptr;
614
615 int32_t ret = allConnectManager.RegisterLifecycleCallback();
616 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
617 } catch (...) {
618 EXPECT_TRUE(false);
619 }
620 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_002 end";
621 }
622
623 /**
624 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_003
625 * @tc.desc: verify RegisterLifecycleCallback fail.
626 * @tc.type: FUNC
627 * @tc.require: I7TDJK
628 */
629 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_003, TestSize.Level1)
630 {
631 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_003 start";
632 try {
633 auto &allConnectManager = AllConnectManager::GetInstance();
634
635 allConnectManager.dllHandle_ = (void *)0x1;
636 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = [](
637 const char *serviceName,
__anond781708b0902( const char *serviceName, ServiceCollaborationManager_Callback *callback) 638 ServiceCollaborationManager_Callback *callback) -> int32_t {
639 return 1;
640 };
641
642 int32_t ret = allConnectManager.RegisterLifecycleCallback();
643 EXPECT_EQ(ret, FileManagement::ERR_ALLCONNECT);
644 } catch (...) {
645 EXPECT_TRUE(false);
646 }
647 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_003 end";
648 }
649
650 /**
651 * @tc.name: AllConnectManagerTest_RegisterLifecycleCallback_004
652 * @tc.desc: verify RegisterLifecycleCallback success.
653 * @tc.type: FUNC
654 * @tc.require: I7TDJK
655 */
656 HWTEST_F(AllConnectManagerTest, RegisterLifecycleCallback_004, TestSize.Level1)
657 {
658 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_004 start";
659 try {
660 auto &allConnectManager = AllConnectManager::GetInstance();
661
662 allConnectManager.dllHandle_ = (void *)0x1;
663 allConnectManager.allConnect_.ServiceCollaborationManager_RegisterLifecycleCallback = [](
664 const char *serviceName,
__anond781708b0a02( const char *serviceName, ServiceCollaborationManager_Callback *callback) 665 ServiceCollaborationManager_Callback *callback) -> int32_t {
666 return 0;
667 };
668
669 int32_t ret = allConnectManager.RegisterLifecycleCallback();
670 EXPECT_EQ(ret, FileManagement::ERR_OK);
671 } catch (...) {
672 EXPECT_TRUE(false);
673 }
674 GTEST_LOG_(INFO) << "RegisterLifecycleCallback_004 end";
675 }
676
677 /**
678 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_001
679 * @tc.desc: verify UnRegisterLifecycleCallback dllHandle_ is nullptr.
680 * @tc.type: FUNC
681 * @tc.require: I7TDJK
682 */
683 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_001, TestSize.Level1)
684 {
685 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_001 start";
686 try {
687 auto &allConnectManager = AllConnectManager::GetInstance();
688
689 allConnectManager.dllHandle_ = nullptr;
690
691 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
692 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
693 } catch (...) {
694 EXPECT_TRUE(false);
695 }
696 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_001 end";
697 }
698
699 /**
700 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_002
701 * @tc.desc: verify UnRegisterLifecycleCallback allConnect_ is nullptr.
702 * @tc.type: FUNC
703 * @tc.require: I7TDJK
704 */
705 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_002, TestSize.Level1)
706 {
707 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_002 start";
708 try {
709 auto &allConnectManager = AllConnectManager::GetInstance();
710
711 allConnectManager.dllHandle_ = (void *)0x1;
712 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = nullptr;
713
714 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
715 EXPECT_EQ(ret, FileManagement::ERR_DLOPEN);
716 } catch (...) {
717 EXPECT_TRUE(false);
718 }
719 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_002 end";
720 }
721
722 /**
723 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_003
724 * @tc.desc: verify UnRegisterLifecycleCallback fail.
725 * @tc.type: FUNC
726 * @tc.require: I7TDJK
727 */
728 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_003, TestSize.Level1)
729 {
730 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_003 start";
731 try {
732 auto &allConnectManager = AllConnectManager::GetInstance();
733
734 allConnectManager.dllHandle_ = (void *)0x1;
735 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = [](
__anond781708b0b02( const char *serviceName) 736 const char *serviceName) -> int32_t {
737 return 1;
738 };
739
740 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
741 EXPECT_EQ(ret, FileManagement::ERR_ALLCONNECT);
742 } catch (...) {
743 EXPECT_TRUE(false);
744 }
745 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_003 end";
746 }
747
748 /**
749 * @tc.name: AllConnectManagerTest_UnRegisterLifecycleCallback_004
750 * @tc.desc: verify UnRegisterLifecycleCallback success.
751 * @tc.type: FUNC
752 * @tc.require: I7TDJK
753 */
754 HWTEST_F(AllConnectManagerTest, UnRegisterLifecycleCallback_004, TestSize.Level1)
755 {
756 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_004 start";
757 try {
758 auto &allConnectManager = AllConnectManager::GetInstance();
759
760 allConnectManager.dllHandle_ = (void *)0x1;
761 allConnectManager.allConnect_.ServiceCollaborationManager_UnRegisterLifecycleCallback = [](
__anond781708b0c02( const char *serviceName) 762 const char *serviceName) -> int32_t {
763 return 0;
764 };
765
766 int32_t ret = allConnectManager.UnRegisterLifecycleCallback();
767 EXPECT_EQ(ret, FileManagement::ERR_OK);
768 } catch (...) {
769 EXPECT_TRUE(false);
770 }
771 GTEST_LOG_(INFO) << "UnRegisterLifecycleCallback_004 end";
772 }
773
774 /**
775 * @tc.name: AllConnectManagerTest_OnStop_001
776 * @tc.desc: verify OnStop.
777 * @tc.type: FUNC
778 * @tc.require: I7TDJK
779 */
780 HWTEST_F(AllConnectManagerTest, OnStop_001, TestSize.Level1)
781 {
782 GTEST_LOG_(INFO) << "OnStop_001 start";
783 try {
784 auto &allConnectManager = AllConnectManager::GetInstance();
785
786 int32_t ret = allConnectManager.OnStop("");
787 EXPECT_EQ(ret, FileManagement::ERR_OK);
788 } catch (...) {
789 EXPECT_TRUE(false);
790 }
791 GTEST_LOG_(INFO) << "OnStop_001 end";
792 }
793
794 /**
795 * @tc.name: AllConnectManagerTest_ApplyResult_001
796 * @tc.desc: verify ApplyResult result is REJECT.
797 * @tc.type: FUNC
798 * @tc.require: I7TDJK
799 */
800 HWTEST_F(AllConnectManagerTest, ApplyResult_001, TestSize.Level1)
801 {
802 GTEST_LOG_(INFO) << "ApplyResult_001 start";
803 try {
804 auto &allConnectManager = AllConnectManager::GetInstance();
805
806 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
807 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
808
809 int32_t ret = allConnectManager.ApplyResult(0, REJECT, "");
810 EXPECT_EQ(ret, FileManagement::ERR_APPLY_RESULT);
811 EXPECT_EQ(allConnectManager.applyResultBlock_ -> GetValue(), false);
812 } catch (...) {
813 EXPECT_TRUE(false);
814 }
815 GTEST_LOG_(INFO) << "ApplyResult_001 end";
816 }
817
818 /**
819 * @tc.name: AllConnectManagerTest_ApplyResult_002
820 * @tc.desc: verify ApplyResult result is PASS.
821 * @tc.type: FUNC
822 * @tc.require: I7TDJK
823 */
824 HWTEST_F(AllConnectManagerTest, ApplyResult_002, TestSize.Level1)
825 {
826 GTEST_LOG_(INFO) << "ApplyResult_002 start";
827 try {
828 auto &allConnectManager = AllConnectManager::GetInstance();
829
830 allConnectManager.applyResultBlock_ = std::make_shared<BlockObject<bool>>(
831 AllConnectManager::BLOCK_INTERVAL_ALLCONNECT, false);
832
833 int32_t ret = allConnectManager.ApplyResult(0, PASS, "");
834 EXPECT_EQ(ret, FileManagement::ERR_OK);
835 EXPECT_EQ(allConnectManager.applyResultBlock_->GetValue(), true);
836 } catch (...) {
837 EXPECT_TRUE(false);
838 }
839 GTEST_LOG_(INFO) << "ApplyResult_002 end";
840 }
841
842 /**
843 * @tc.name: AllConnectManagerTest_BuildResourceRequest_001
844 * @tc.desc: verify BuildResourceRequest.
845 * @tc.type: FUNC
846 * @tc.require: I7TDJK
847 */
848 HWTEST_F(AllConnectManagerTest, BuildResourceRequest_001, TestSize.Level1)
849 {
850 GTEST_LOG_(INFO) << "BuildResourceRequest_001 start";
851 try {
852 auto &allConnectManager = AllConnectManager::GetInstance();
853
854 auto ret = allConnectManager.BuildResourceRequest();
855 EXPECT_TRUE(ret != nullptr);
856 } catch (...) {
857 EXPECT_TRUE(false);
858 }
859 GTEST_LOG_(INFO) << "BuildResourceRequest_001 end";
860 }
861 }
862 } // namespace DistributedFile
863 } // namespace Storage
864 } // namespace OHOS
865