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