1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <fcntl.h>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <sys/stat.h>
20
21 #include "asset_recv_callback_mock.h"
22 #include "asset_send_callback_mock.h"
23 #include "dfs_error.h"
24 #include "distributed_file_daemon_manager_impl.h"
25 #include "distributed_file_daemon_proxy.h"
26 #include "ipc/hmdfs_info.h"
27 #include "i_daemon_mock.h"
28 #include "file_dfs_listener_mock.h"
29 #include "utils_log.h"
30 namespace {
31 bool g_isNullptr = false;
32 }
33 namespace OHOS::Storage::DistributedFile {
GetInstance()34 sptr<IDaemon> DistributedFileDaemonProxy::GetInstance()
35 {
36 if (!g_isNullptr) {
37 daemonProxy_ = iface_cast<IDaemon>(sptr(new DaemonServiceMock()));
38 return daemonProxy_;
39 } else {
40 return nullptr;
41 }
42 }
43 namespace Test {
44 using namespace OHOS::FileManagement;
45 using namespace testing;
46 using namespace testing::ext;
47 using namespace std;
48
49 constexpr int32_t FILE_NOT_FOUND = 2;
50 namespace {
51 DistributedHardware::DmDeviceInfo deviceInfo = {
52 .deviceId = "testdevid",
53 .deviceName = "testdevname",
54 .networkId = "testnetworkid",
55 };
56 }
57
58 class DistributedDaemonManagerImplTest : public testing::Test {
59 public:
60 static void SetUpTestCase(void);
61 static void TearDownTestCase(void);
62 void SetUp();
63 void TearDown();
64 std::shared_ptr<DistributedFileDaemonManagerImpl> distributedDaemonManagerImpl_;
65 };
66
SetUpTestCase(void)67 void DistributedDaemonManagerImplTest::SetUpTestCase(void)
68 {
69 GTEST_LOG_(INFO) << "SetUpTestCase";
70 g_isNullptr = false;
71 }
72
TearDownTestCase(void)73 void DistributedDaemonManagerImplTest::TearDownTestCase(void)
74 {
75 GTEST_LOG_(INFO) << "TearDownTestCase";
76 }
77
SetUp(void)78 void DistributedDaemonManagerImplTest::SetUp(void)
79 {
80 if (distributedDaemonManagerImpl_ == nullptr) {
81 distributedDaemonManagerImpl_ = std::make_shared<DistributedFileDaemonManagerImpl>();
82 ASSERT_TRUE(distributedDaemonManagerImpl_ != nullptr) << "CallbackManager failed";
83 }
84 GTEST_LOG_(INFO) << "SetUp";
85 }
86
TearDown(void)87 void DistributedDaemonManagerImplTest::TearDown(void)
88 {
89 GTEST_LOG_(INFO) << "TearDown";
90 }
91
92 /**
93 * @tc.name: GetInstanceTest
94 * @tc.desc: Verify the GetInstance function
95 * @tc.type: FUNC
96 * @tc.require: I7M6L1
97 */
98 HWTEST_F(DistributedDaemonManagerImplTest, GetInstanceTest, TestSize.Level0)
99 {
100 GTEST_LOG_(INFO) << "GetInstanceTest Start";
101 try {
102 DistributedFileDaemonManagerImpl::GetInstance();
103 EXPECT_TRUE(true);
104 } catch (...) {
105 EXPECT_TRUE(false);
106 GTEST_LOG_(INFO) << "GetInstanceTest ERROR";
107 }
108 GTEST_LOG_(INFO) << "GetInstanceTest End";
109 }
110
111 /**
112 * @tc.name: OpenP2PConnectionTest
113 * @tc.desc: Verify the OpenP2PConnection function
114 * @tc.type: FUNC
115 * @tc.require: I7M6L1
116 */
117 HWTEST_F(DistributedDaemonManagerImplTest, OpenP2PConnectionTest, TestSize.Level0)
118 {
119 GTEST_LOG_(INFO) << "OpenP2PConnectionTest Start";
120 try {
121 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
122 EXPECT_NE(distributedFileDaemonProxy, nullptr);
123 auto res = distributedDaemonManagerImpl_->OpenP2PConnection(deviceInfo);
124 EXPECT_NE(res, E_SA_LOAD_FAILED);
125 } catch (...) {
126 EXPECT_TRUE(false);
127 GTEST_LOG_(INFO) << "OpenP2PConnectionTest ERROR";
128 }
129 GTEST_LOG_(INFO) << "OpenP2PConnectionTest End";
130 }
131
132 /**
133 * @tc.name: CloseP2PConnectionTest
134 * @tc.desc: Verify the CloseP2PConnection function
135 * @tc.type: FUNC
136 * @tc.require: I7M6L1
137 */
138 HWTEST_F(DistributedDaemonManagerImplTest, CloseP2PConnectionTest, TestSize.Level0)
139 {
140 GTEST_LOG_(INFO) << "CloseP2PConnectionTest Start";
141 try {
142 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
143 EXPECT_NE(distributedFileDaemonProxy, nullptr);
144 auto res = distributedDaemonManagerImpl_->CloseP2PConnection(deviceInfo);
145 EXPECT_NE(res, E_SA_LOAD_FAILED);
146 } catch (...) {
147 EXPECT_TRUE(false);
148 GTEST_LOG_(INFO) << "CloseP2PConnectionTest ERROR";
149 }
150 GTEST_LOG_(INFO) << "CloseP2PConnectionTest End";
151 }
152
153 /**
154 * @tc.name: OpenP2PConnectionExTest
155 * @tc.desc: Verify the OpenP2PConnectionEx function
156 * @tc.type: FUNC
157 * @tc.require: I7M6L1
158 */
159 HWTEST_F(DistributedDaemonManagerImplTest, OpenP2PConnectionExTest, TestSize.Level0)
160 {
161 auto remoteReverseObj = sptr(new FileDfsListenerMock());
162 GTEST_LOG_(INFO) << "OpenP2PConnectionExTest Start";
163 try {
164 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
165 EXPECT_NE(distributedFileDaemonProxy, nullptr);
166 auto res = distributedDaemonManagerImpl_->OpenP2PConnectionEx("test", remoteReverseObj);
167 EXPECT_NE(res, E_SA_LOAD_FAILED);
168 } catch (...) {
169 EXPECT_TRUE(false);
170 GTEST_LOG_(INFO) << "OpenP2PConnectionExTest ERROR";
171 }
172 GTEST_LOG_(INFO) << "OpenP2PConnectionExTest End";
173 }
174
175 /**
176 * @tc.name: CloseP2PConnectionEx
177 * @tc.desc: Verify the CloseP2PConnectionEx function
178 * @tc.type: FUNC
179 * @tc.require: I7M6L1
180 */
181 HWTEST_F(DistributedDaemonManagerImplTest, CloseP2PConnectionExTest, TestSize.Level0)
182 {
183 GTEST_LOG_(INFO) << "CloseP2PConnectionEx Start";
184 try {
185 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
186 EXPECT_NE(distributedFileDaemonProxy, nullptr);
187 auto res = distributedDaemonManagerImpl_->CloseP2PConnectionEx("test");
188 EXPECT_NE(res, E_SA_LOAD_FAILED);
189 } catch (...) {
190 EXPECT_TRUE(false);
191 GTEST_LOG_(INFO) << "CloseP2PConnectionEx ERROR";
192 }
193 GTEST_LOG_(INFO) << "CloseP2PConnectionEx End";
194 }
195
196 /**
197 * @tc.name: PrepareSessionTest
198 * @tc.desc: Verify the PrepareSession function
199 * @tc.type: FUNC
200 * @tc.require: I7M6L1
201 */
202 HWTEST_F(DistributedDaemonManagerImplTest, PrepareSessionTest, TestSize.Level0)
203 {
204 const std::string srcUri = "file://docs/storage/Users/currentUser/Documents?networkId=xxxxx";
205 const std::string dstUri = "file://docs/storage/Users/currentUser/Documents";
206 const std::string srcDeviceId = "testSrcDeviceId";
207 const sptr<IRemoteObject> listener = sptr(new DaemonServiceMock());
208 const std::string copyPath = "tmpDir";
209 const std::string sessionName = "DistributedDevice0";
210 HmdfsInfo fileInfo = {
211 .copyPath = copyPath,
212 .dirExistFlag = false,
213 .sessionName = sessionName,
214 };
215 GTEST_LOG_(INFO) << "PrepareSessionTest Start";
216 try {
217 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
218 EXPECT_NE(distributedFileDaemonProxy, nullptr);
219 auto res = distributedDaemonManagerImpl_->PrepareSession(srcUri, dstUri, srcDeviceId, listener, fileInfo);
220 EXPECT_NE(res, E_SA_LOAD_FAILED);
221 } catch (...) {
222 EXPECT_TRUE(false);
223 GTEST_LOG_(INFO) << "PrepareSessionTest ERROR";
224 }
225 GTEST_LOG_(INFO) << "PrepareSessionTest End";
226 }
227
228 /**
229 * @tc.name: RequestSendFileTest
230 * @tc.desc: Verify the RequestSendFile function
231 * @tc.type: FUNC
232 * @tc.require: I7M6L1
233 */
234 HWTEST_F(DistributedDaemonManagerImplTest, RequestSendFileTest, TestSize.Level0)
235 {
236 GTEST_LOG_(INFO) << "RequestSendFileTest Start";
237 try {
238 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
239 EXPECT_NE(distributedFileDaemonProxy, nullptr);
240 auto res = distributedDaemonManagerImpl_->RequestSendFile("uri", "path", "deviceId", "test");
241 EXPECT_NE(res, E_SA_LOAD_FAILED);
242 } catch (...) {
243 EXPECT_TRUE(false);
244 GTEST_LOG_(INFO) << "RequestSendFileTest ERROR";
245 }
246 GTEST_LOG_(INFO) << "RequestSendFileTest End";
247 }
248
249 /**
250 * @tc.name: GetRemoteCopyInfoTest
251 * @tc.desc: Verify the GetRemoteCopyInfo function
252 * @tc.type: FUNC
253 * @tc.require: I7M6L1
254 */
255 HWTEST_F(DistributedDaemonManagerImplTest, GetRemoteCopyInfoTest, TestSize.Level0)
256 {
257 bool isFile = false;
258 bool isDir = false;
259 GTEST_LOG_(INFO) << "GetRemoteCopyInfoTest Start";
260 try {
261 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
262 EXPECT_NE(distributedFileDaemonProxy, nullptr);
263 auto res = distributedDaemonManagerImpl_->GetRemoteCopyInfo("test", isFile, isDir);
264 EXPECT_NE(res, E_SA_LOAD_FAILED);
265 } catch (...) {
266 EXPECT_TRUE(false);
267 GTEST_LOG_(INFO) << "GetRemoteCopyInfoTest ERROR";
268 }
269 GTEST_LOG_(INFO) << "GetRemoteCopyInfoTest End";
270 }
271
272 /**
273 * @tc.name: PushAssetTest
274 * @tc.desc: Verify the PushAsset function
275 * @tc.type: FUNC
276 * @tc.require: I7M6L1
277 */
278 HWTEST_F(DistributedDaemonManagerImplTest, PushAssetTest, TestSize.Level0)
279 {
280 sptr<AssetObj> assetObj = nullptr;
281 int32_t userId = 800;
282 GTEST_LOG_(INFO) << "PushAssetTest Start";
283 try {
284 sptr<IAssetSendCallbackMock> errPtr = nullptr;
285 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
286 EXPECT_NE(distributedFileDaemonProxy, nullptr);
287 auto res = distributedDaemonManagerImpl_->PushAsset(userId, assetObj, nullptr);
288 EXPECT_NE(res, E_SA_LOAD_FAILED);
289 } catch (...) {
290 EXPECT_TRUE(false);
291 GTEST_LOG_(INFO) << "PushAssetTest ERROR";
292 }
293 GTEST_LOG_(INFO) << "PushAssetTest End";
294 }
295
296 /**
297 * @tc.name: RegisterAssetCallbackTest
298 * @tc.desc: Verify the RegisterAssetCallback function
299 * @tc.type: FUNC
300 * @tc.require: I7M6L1
301 */
302 HWTEST_F(DistributedDaemonManagerImplTest, RegisterAssetCallbackTest, TestSize.Level0)
303 {
304 GTEST_LOG_(INFO) << "RegisterAssetCallbackTest Start";
305 try {
306 sptr<IAssetRecvCallbackMock> errPtr = nullptr;
307 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
308 EXPECT_NE(distributedFileDaemonProxy, nullptr);
309 auto res = distributedDaemonManagerImpl_->RegisterAssetCallback(errPtr);
310 EXPECT_EQ(res, E_NULLPTR);
311 auto callbackMock = sptr(new IAssetRecvCallbackMock());
312 res = distributedDaemonManagerImpl_->RegisterAssetCallback(callbackMock);
313 EXPECT_NE(res, E_SA_LOAD_FAILED);
314 } catch (...) {
315 EXPECT_TRUE(false);
316 GTEST_LOG_(INFO) << "RegisterAssetCallbackTest ERROR";
317 }
318 GTEST_LOG_(INFO) << "RegisterAssetCallbackTest End";
319 }
320
321 /**
322 * @tc.name: UnRegisterAssetCallbackTest
323 * @tc.desc: Verify the UnRegisterAssetCallback function
324 * @tc.type: FUNC
325 * @tc.require: I7M6L1
326 */
327 HWTEST_F(DistributedDaemonManagerImplTest, UnRegisterAssetCallbackTest, TestSize.Level0)
328 {
329 GTEST_LOG_(INFO) << "UnRegisterAssetCallbackTest Start";
330 try {
331 sptr<IAssetRecvCallbackMock> errPtr = nullptr;
332 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
333 EXPECT_NE(distributedFileDaemonProxy, nullptr);
334 auto res = distributedDaemonManagerImpl_->UnRegisterAssetCallback(errPtr);
335 EXPECT_EQ(res, E_NULLPTR);
336
337 auto callbackMock = sptr(new IAssetRecvCallbackMock());
338 res = distributedDaemonManagerImpl_->UnRegisterAssetCallback(callbackMock);
339 EXPECT_NE(res, E_SA_LOAD_FAILED);
340 } catch (...) {
341 EXPECT_TRUE(false);
342 GTEST_LOG_(INFO) << "UnRegisterAssetCallbackTest ERROR";
343 }
344 GTEST_LOG_(INFO) << "UnRegisterAssetCallbackTest End";
345 }
346
347 /**
348 * @tc.name: CancelTest
349 * @tc.desc: Verify the Cancel function
350 * @tc.type: FUNC
351 * @tc.require: I7M6L1
352 */
353 HWTEST_F(DistributedDaemonManagerImplTest, CancelTest, TestSize.Level0)
354 {
355 GTEST_LOG_(INFO) << "CancelTest Start";
356 try {
357 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
358 EXPECT_NE(distributedFileDaemonProxy, nullptr);
359 int32_t ret = distributedDaemonManagerImpl_->Cancel();
360 EXPECT_EQ(ret, E_OK);
361
362 std::string srcUri = "srcUri";
363 std::string dstUri = "dstUri";
364 ret = distributedDaemonManagerImpl_->Cancel(srcUri, dstUri);
365 EXPECT_EQ(ret, E_OK);
366
367 dstUri = "../../dstUri";
368 ret = distributedDaemonManagerImpl_->Cancel(srcUri, dstUri);
369 EXPECT_EQ(ret, EINVAL);
370
371 srcUri = "../../srcUri";
372 ret = distributedDaemonManagerImpl_->Cancel(srcUri, dstUri);
373 EXPECT_EQ(ret, EINVAL);
374 } catch (...) {
375 EXPECT_TRUE(false);
376 GTEST_LOG_(INFO) << "CancelTest ERROR";
377 }
378 GTEST_LOG_(INFO) << "CancelTest End";
379 }
380
381 /**
382 * @tc.name: CopyTest
383 * @tc.desc: Verify the Copy function
384 * @tc.type: FUNC
385 * @tc.require: I7M6L1
386 */
387 HWTEST_F(DistributedDaemonManagerImplTest, CopyTest, TestSize.Level0)
388 {
389 GTEST_LOG_(INFO) << "CopyTest Start";
390 try {
391 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
392 EXPECT_NE(distributedFileDaemonProxy, nullptr);
393 std::string srcUri = "srcUri";
394 std::string dstUri = "dstUri";
395 int32_t ret = distributedDaemonManagerImpl_->Copy(srcUri, dstUri, nullptr);
396 EXPECT_EQ(ret, EINVAL);
397
398 dstUri = "../dstUri";
399 ret = distributedDaemonManagerImpl_->Copy(srcUri, dstUri, nullptr);
400 EXPECT_EQ(ret, EINVAL);
401
402 srcUri = "../srcUri";
403 ret = distributedDaemonManagerImpl_->Copy(srcUri, dstUri, nullptr);
404 EXPECT_EQ(ret, EINVAL);
405 } catch (...) {
406 EXPECT_TRUE(false);
407 GTEST_LOG_(INFO) << "CopyTest ERROR";
408 }
409 GTEST_LOG_(INFO) << "CopyTest End";
410 }
411
412 /**
413 * @tc.name: IsDirectoryTest
414 * @tc.desc: Verify the IsDirectory function
415 * @tc.type: FUNC
416 * @tc.require: I7M6L1
417 */
418 HWTEST_F(DistributedDaemonManagerImplTest, IsDirectoryTest, TestSize.Level0)
419 {
420 GTEST_LOG_(INFO) << "IsDirectoryTest Start";
421 try {
422 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
423 EXPECT_NE(distributedFileDaemonProxy, nullptr);
424 bool isDirectory = false;
425 std::string srcUri = "srcUri";
426 int32_t ret = distributedDaemonManagerImpl_->IsDirectory(srcUri, true, isDirectory);
427 EXPECT_EQ(ret, FILE_NOT_FOUND);
428
429 srcUri = "../srcUri";
430 ret = distributedDaemonManagerImpl_->IsDirectory(srcUri, true, isDirectory);
431 EXPECT_EQ(ret, OHOS::FileManagement::E_ILLEGAL_URI);
432 } catch (...) {
433 EXPECT_TRUE(false);
434 GTEST_LOG_(INFO) << "IsDirectoryTest ERROR";
435 }
436 GTEST_LOG_(INFO) << "IsDirectoryTest End";
437 }
438
439 /**
440 * @tc.name: GetSizeTest
441 * @tc.desc: Verify the GetSize function
442 * @tc.type: FUNC
443 * @tc.require: I7M6L1
444 */
445 HWTEST_F(DistributedDaemonManagerImplTest, GetSizeTest, TestSize.Level0)
446 {
447 GTEST_LOG_(INFO) << "GetSizeTest Start";
448 try {
449 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
450 EXPECT_NE(distributedFileDaemonProxy, nullptr);
451 uint64_t size = 0;
452 std::string srcUri = "srcUri";
453 int32_t ret = distributedDaemonManagerImpl_->GetSize(srcUri, true, size);
454 EXPECT_TRUE(size == 0);
455 EXPECT_EQ(ret, FILE_NOT_FOUND);
456
457 srcUri = "../srcUri";
458 ret = distributedDaemonManagerImpl_->GetSize(srcUri, true, size);
459 EXPECT_TRUE(size == 0);
460 } catch (...) {
461 EXPECT_TRUE(false);
462 GTEST_LOG_(INFO) << "GetSizeTest ERROR";
463 }
464 GTEST_LOG_(INFO) << "GetSizeTest End";
465 }
466
467 /**
468 * @tc.name: GetDfsSwitchStatusTest
469 * @tc.desc: Verify the GetDfsSwitchStatus function
470 * @tc.type: FUNC
471 * @tc.require: I7M6L1
472 */
473 HWTEST_F(DistributedDaemonManagerImplTest, GetDfsSwitchStatusTest, TestSize.Level1)
474 {
475 GTEST_LOG_(INFO) << "GetDfsSwitchStatusTest Start";
476 try {
477 g_isNullptr = false;
478 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
479 EXPECT_NE(distributedFileDaemonProxy, nullptr);
480 int32_t switchStatus = 0;
481 std::string networkId = "test";
482 auto res = distributedDaemonManagerImpl_->GetDfsSwitchStatus(networkId, switchStatus);
483 EXPECT_NE(res, E_SA_LOAD_FAILED);
484
485 g_isNullptr = true;
486 res = distributedDaemonManagerImpl_->GetDfsSwitchStatus(networkId, switchStatus);
487 EXPECT_EQ(res, E_SA_LOAD_FAILED);
488 } catch (...) {
489 EXPECT_TRUE(false);
490 GTEST_LOG_(INFO) << "GetDfsSwitchStatusTest ERROR";
491 }
492 GTEST_LOG_(INFO) << "GetDfsSwitchStatusTest End";
493 }
494
495 /**
496 * @tc.name: UpdateDfsSwitchStatusTest
497 * @tc.desc: Verify the UpdateDfsSwitchStatus function
498 * @tc.type: FUNC
499 * @tc.require: I7M6L1
500 */
501 HWTEST_F(DistributedDaemonManagerImplTest, UpdateDfsSwitchStatusTest, TestSize.Level1)
502 {
503 GTEST_LOG_(INFO) << "UpdateDfsSwitchStatusTest Start";
504 try {
505 g_isNullptr = false;
506 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
507 EXPECT_NE(distributedFileDaemonProxy, nullptr);
508 int32_t switchStatus = 0;
509 auto res = distributedDaemonManagerImpl_->UpdateDfsSwitchStatus(switchStatus);
510 EXPECT_NE(res, E_SA_LOAD_FAILED);
511
512 g_isNullptr = true;
513 res = distributedDaemonManagerImpl_->UpdateDfsSwitchStatus(switchStatus);
514 EXPECT_EQ(res, E_SA_LOAD_FAILED);
515 } catch (...) {
516 EXPECT_TRUE(false);
517 GTEST_LOG_(INFO) << "UpdateDfsSwitchStatusTest ERROR";
518 }
519 GTEST_LOG_(INFO) << "UpdateDfsSwitchStatusTest End";
520 }
521
522 /**
523 * @tc.name: GetConnectedDeviceListTest
524 * @tc.desc: Verify the GetConnectedDeviceList function
525 * @tc.type: FUNC
526 * @tc.require: I7M6L1
527 */
528 HWTEST_F(DistributedDaemonManagerImplTest, GetConnectedDeviceListTest, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO) << "GetConnectedDeviceListTest Start";
531 try {
532 g_isNullptr = false;
533 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
534 EXPECT_NE(distributedFileDaemonProxy, nullptr);
535 std::vector<DfsDeviceInfo> deviceList;
536 auto res = distributedDaemonManagerImpl_->GetConnectedDeviceList(deviceList);
537 EXPECT_NE(res, E_SA_LOAD_FAILED);
538
539 g_isNullptr = true;
540 res = distributedDaemonManagerImpl_->GetConnectedDeviceList(deviceList);
541 EXPECT_EQ(res, E_SA_LOAD_FAILED);
542 } catch (...) {
543 EXPECT_TRUE(false);
544 GTEST_LOG_(INFO) << "GetConnectedDeviceListTest ERROR";
545 }
546 GTEST_LOG_(INFO) << "GetConnectedDeviceListTest End";
547 }
548 } // namespace Test
549 } // namespace OHOS::Storage::DistributedFile
550