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