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 <gtest/gtest.h>
17
18 #include "battersrvclient_mock.h"
19 #include "cloud_file_kit.h"
20 #include "cloud_sync_common.h"
21 #include "cloud_sync_service.h"
22 #include "dfsu_access_token_helper_mock.h"
23 #include "i_cloud_download_callback_mock.h"
24 #include "service_callback_mock.h"
25 #include "system_ability_manager_client_mock.h"
26
27 namespace OHOS {
28 namespace FileManagement::CloudSync {
29 namespace Test {
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace std;
33 using namespace CloudFile;
34 using ChargeState = PowerMgr::BatteryChargeState;
35 using PluggedType = PowerMgr::BatteryPluggedType;
36 constexpr int32_t SA_ID = 5204;
37
38 class CloudFileKitMock : public CloudFile::CloudFileKit {
39 public:
40 MOCK_METHOD2(GetCloudUserInfo, int32_t(const int32_t userId, CloudFile::CloudUserInfo &userInfo));
41 MOCK_METHOD3(GetAppSwitchStatus, int32_t(const std::string &bundleName, const int32_t userId, bool &switchStatus));
42 MOCK_METHOD3(GetAppConfigParams, int32_t(const int32_t userId,
43 const std::string &bundleName, std::map<std::string, std::string> ¶m));
44 MOCK_METHOD2(GetCloudAssetsDownloader, std::shared_ptr<CloudAssetsDownloader>(const int32_t userId,
45 const std::string &bundleName));
46 };
47
48 class CloudSyncServiceTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 static inline std::shared_ptr<SystemAbilityManagerClientMock> saMgrClient_ = nullptr;
55 static inline sptr<ISystemAbilityManagerMock> saMgr_ = nullptr;
56 static inline shared_ptr<DfsuAccessTokenMock> dfsuAccessToken_ = nullptr;
57 static inline sptr<CloudSyncService> servicePtr_ = nullptr;
58 static inline shared_ptr<BatterySrvClientMock> dfsBatterySrvClient_ = nullptr;
59 };
60
SetUpTestCase(void)61 void CloudSyncServiceTest::SetUpTestCase(void)
62 {
63 std::cout << "SetUpTestCase" << std::endl;
64 servicePtr_ = sptr(new CloudSyncService(SA_ID));
65 saMgr_ = sptr(new ISystemAbilityManagerMock());
66 saMgrClient_ = make_shared<SystemAbilityManagerClientMock>();
67 ISystemAbilityManagerClient::smc = saMgrClient_;
68 servicePtr_->dataSyncManager_ = make_shared<CloudFile::DataSyncManager>();
69 dfsuAccessToken_ = make_shared<DfsuAccessTokenMock>();
70 DfsuAccessTokenMock::dfsuAccessToken = dfsuAccessToken_;
71 dfsBatterySrvClient_ = make_shared<BatterySrvClientMock>();
72 BatterySrvClientMock::dfsBatterySrvClient = dfsBatterySrvClient_;
73 }
74
TearDownTestCase(void)75 void CloudSyncServiceTest::TearDownTestCase(void)
76 {
77 DfsuAccessTokenMock::dfsuAccessToken = nullptr;
78 ISystemAbilityManagerClient::smc = nullptr;
79 dfsuAccessToken_ = nullptr;
80 saMgrClient_ = nullptr;
81 servicePtr_ = nullptr;
82 saMgr_ = nullptr;
83 BatterySrvClientMock::dfsBatterySrvClient = nullptr;
84 dfsBatterySrvClient_ = nullptr;
85 std::cout << "TearDownTestCase" << std::endl;
86 }
87
SetUp(void)88 void CloudSyncServiceTest::SetUp(void)
89 {
90 std::cout << "SetUp" << std::endl;
91 }
92
TearDown(void)93 void CloudSyncServiceTest::TearDown(void)
94 {
95 std::cout << "TearDown" << std::endl;
96 }
97
98 /**
99 * @tc.name: ChangeAppSwitchTest001
100 * @tc.desc: Verify the ChangeAppSwitch function.
101 * @tc.type: FUNC
102 * @tc.require: NA
103 */
104 HWTEST_F(CloudSyncServiceTest, ChangeAppSwitchTest001, TestSize.Level1)
105 {
106 GTEST_LOG_(INFO) << "ChangeAppSwitchTest001 start";
107 try {
108 EXPECT_NE(servicePtr_, nullptr);
109 std::string accountId = "";
110 bool status = false;
111 std::string bundleName = "com.ohos.photos";
112
113 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
114 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(100));
115
116 int32_t ret = servicePtr_->ChangeAppSwitch(accountId, bundleName, status);
117 EXPECT_EQ(ret, E_OK);
118 } catch (...) {
119 EXPECT_FALSE(true);
120 GTEST_LOG_(INFO) << "ChangeAppSwitchTest001 failed";
121 }
122 GTEST_LOG_(INFO) << "ChangeAppSwitchTest001 end";
123 }
124
125 /**
126 * @tc.name: ChangeAppSwitchTest002
127 * @tc.desc: Verify the ChangeAppSwitch function.
128 * @tc.type: FUNC
129 * @tc.require: NA
130 */
131 HWTEST_F(CloudSyncServiceTest, ChangeAppSwitchTest002, TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "ChangeAppSwitchTest002 start";
134 try {
135 EXPECT_NE(servicePtr_, nullptr);
136 std::string accountId = "";
137 bool status = false;
138 std::string bundleName = "com.ohos.ailife";
139
140 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
141 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(100));
142
143 int32_t ret = servicePtr_->ChangeAppSwitch(accountId, bundleName, status);
144 EXPECT_EQ(ret, E_OK);
145 } catch (...) {
146 EXPECT_FALSE(true);
147 GTEST_LOG_(INFO) << "ChangeAppSwitchTest002 failed";
148 }
149 GTEST_LOG_(INFO) << "ChangeAppSwitchTest002 end";
150 }
151
152 /**
153 * @tc.name: ChangeAppSwitchTest003
154 * @tc.desc: Verify the ChangeAppSwitch function.
155 * @tc.type: FUNC
156 * @tc.require: NA
157 */
158 HWTEST_F(CloudSyncServiceTest, ChangeAppSwitchTest003, TestSize.Level1)
159 {
160 GTEST_LOG_(INFO) << "ChangeAppSwitchTest003 start";
161 try {
162 EXPECT_NE(servicePtr_, nullptr);
163 std::string accountId = "";
164 bool status = false;
165 std::string bundleName = "com.ohos.xxxxxx";
166
167 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
168 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(100));
169
170 int32_t ret = servicePtr_->ChangeAppSwitch(accountId, bundleName, status);
171 EXPECT_EQ(ret, E_OK);
172 } catch (...) {
173 EXPECT_FALSE(true);
174 GTEST_LOG_(INFO) << "ChangeAppSwitchTest003 failed";
175 }
176 GTEST_LOG_(INFO) << "ChangeAppSwitchTest003 end";
177 }
178
179 /**
180 * @tc.name:UnRegisterCallbackInnerTest
181 * @tc.desc:Verify the UnRegisterCallbackInner function.
182 * @tc.type:FUNC
183 * @tc.require: I6H5MH
184 */
185 HWTEST_F(CloudSyncServiceTest, UnRegisterCallbackInnerTest, TestSize.Level1)
186 {
187 GTEST_LOG_(INFO) << "UnRegisterCallbackInner Start";
188 try {
189 std::string bundleName = "";
190 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
191 int ret = servicePtr_->UnRegisterCallbackInner(bundleName);
192 EXPECT_EQ(ret, E_PERMISSION_DENIED);
193 } catch (...) {
194 EXPECT_TRUE(false);
195 GTEST_LOG_(INFO) << "UnRegisterCallbackInner FAILED";
196 }
197 GTEST_LOG_(INFO) << "UnRegisterCallbackInner End";
198 }
199
200 /**
201 * @tc.name:RegisterCallbackInnerTest001
202 * @tc.desc:Verify the RegisterCallbackInner function.
203 * @tc.type:FUNC
204 * @tc.require: I6H5MH
205 */
206 HWTEST_F(CloudSyncServiceTest, RegisterCallbackInnerTest001, TestSize.Level1)
207 {
208 GTEST_LOG_(INFO) << "RegisterCallbackInner start";
209 try {
210 std::string bundleName = "";
211 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
212 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
213 int ret = servicePtr_->RegisterCallbackInner(callback, bundleName);
214 EXPECT_EQ(ret, E_PERMISSION_DENIED);
215 } catch (...) {
216 EXPECT_TRUE(false);
217 GTEST_LOG_(INFO) << "RegisterCallbackInner FAILED";
218 }
219 GTEST_LOG_(INFO) << "RegisterCallbackInner end";
220 }
221
222 /**
223 * @tc.name:RegisterCallbackInnerTest002
224 * @tc.desc:Verify the RegisterCallbackInner function.
225 * @tc.type:FUNC
226 * @tc.require: I6H5MH
227 */
228 HWTEST_F(CloudSyncServiceTest, RegisterCallbackInnerTest002, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch start";
231 try {
232 std::string bundleName = "com.ohos.photos";
233 sptr<CloudSyncCallbackMock> callback = nullptr;
234 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
235 int ret = servicePtr_->RegisterCallbackInner(callback, bundleName);
236 EXPECT_EQ(ret, E_PERMISSION_DENIED);
237 } catch (...) {
238 EXPECT_TRUE(false);
239 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch FAILED";
240 }
241 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch end";
242 }
243
244 /**
245 * @tc.name:TriggerSyncInnerTest
246 * @tc.desc:Verify the TriggerSyncInner function.
247 * @tc.type:FUNC
248 * @tc.require: I6H5MH
249 */
250 HWTEST_F(CloudSyncServiceTest, TriggerSyncInnerTest, TestSize.Level1)
251 {
252 GTEST_LOG_(INFO) << "TriggerSyncInner start";
253 try {
254 std::string bundleName = "com.ohos.photos";
255 int32_t userId = 0;
256 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
257 int ret = servicePtr_->TriggerSyncInner(bundleName, userId);
258 EXPECT_EQ(ret, E_PERMISSION_DENIED);
259 } catch (...) {
260 EXPECT_TRUE(false);
261 GTEST_LOG_(INFO) << "TriggerSyncInner FAILED";
262 }
263 GTEST_LOG_(INFO) << "TriggerSyncInner end";
264 }
265
266 /**
267 * @tc.name:StopSyncInnerTest
268 * @tc.desc:Verify the StopSyncInner function.
269 * @tc.type:FUNC
270 * @tc.require: I6H5MH
271 */
272 HWTEST_F(CloudSyncServiceTest, StopSyncInnerTest, TestSize.Level1)
273 {
274 GTEST_LOG_(INFO) << "StopSyncInner Start";
275 try {
276 std::string bundleName = "";
277 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
278 int ret = servicePtr_->StopSyncInner(bundleName);
279 EXPECT_EQ(ret, E_PERMISSION_DENIED);
280 } catch (...) {
281 EXPECT_TRUE(false);
282 GTEST_LOG_(INFO) << "StopSyncInner FAILED";
283 }
284 GTEST_LOG_(INFO) << "StopSyncInner End";
285 }
286
287 /**
288 * @tc.name:CleanCacheInnerTest
289 * @tc.desc:Verify the CleanCacheInner function.
290 * @tc.type:FUNC
291 * @tc.require: I6H5MH
292 */
293 HWTEST_F(CloudSyncServiceTest, CleanCacheInnerTest, TestSize.Level1)
294 {
295 GTEST_LOG_(INFO) << "CleanCacheInner Start";
296 try {
297 std::string uri = "";
298 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
299 int ret = servicePtr_->CleanCacheInner(uri);
300 EXPECT_EQ(ret, E_PERMISSION_DENIED);
301 } catch (...) {
302 EXPECT_TRUE(false);
303 GTEST_LOG_(INFO) << "CleanCacheInner FAILED";
304 }
305 GTEST_LOG_(INFO) << "CleanCacheInner End";
306 }
307
308 /**
309 * @tc.name:EnableCloudTest
310 * @tc.desc:Verify the EnableCloud function.
311 * @tc.type:FUNC
312 * @tc.require: I6H5MH
313 */
314 HWTEST_F(CloudSyncServiceTest, EnableCloudTest, TestSize.Level1)
315 {
316 GTEST_LOG_(INFO) << "EnableCloud start";
317 try {
318 std::string accountId = "testId";
319 SwitchDataObj switchData;
320 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
321 int ret = servicePtr_->EnableCloud(accountId, switchData);
322 EXPECT_EQ(ret, E_PERMISSION_DENIED);
323 } catch (...) {
324 EXPECT_TRUE(false);
325 GTEST_LOG_(INFO) << "EnableCloud FAILED";
326 }
327 GTEST_LOG_(INFO) << "EnableCloud end";
328 }
329
330 /**
331 * @tc.name:CleanTest
332 * @tc.desc:Verify the Clean function.
333 * @tc.type:FUNC
334 * @tc.require: I6H5MH
335 */
336 HWTEST_F(CloudSyncServiceTest, CleanTest, TestSize.Level1)
337 {
338 GTEST_LOG_(INFO) << "DisableCloud start";
339 try {
340 std::string accountId = "testId";
341 CleanOptions cleanOptions;
342 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
343 int ret = servicePtr_->Clean(accountId, cleanOptions);
344 EXPECT_EQ(ret, E_PERMISSION_DENIED);
345 } catch (...) {
346 EXPECT_TRUE(false);
347 GTEST_LOG_(INFO) << "Clean FAILED";
348 }
349 GTEST_LOG_(INFO) << "Clean end";
350 }
351
352
353 /**
354 * @tc.name:StopDownloadFileTest002
355 * @tc.desc:Verify the StopDownloadFile function.
356 * @tc.type:FUNC
357 * @tc.require: I6H5MH
358 */
359 HWTEST_F(CloudSyncServiceTest, StopDownloadFileTest002, TestSize.Level1)
360 {
361 GTEST_LOG_(INFO) << "StopDownloadFile start";
362 try {
363 int64_t downloadId = 0;
364 bool needClean = false;
365 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
366 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
367 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
368 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
369 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
370 int ret = servicePtr_->StopDownloadFile(downloadId, needClean);
371 EXPECT_EQ(ret, E_OK);
372 } catch (...) {
373 EXPECT_TRUE(false);
374 GTEST_LOG_(INFO) << "StopDownloadFileTest002 FAILED";
375 }
376 GTEST_LOG_(INFO) << "StopDownloadFileTest002 end";
377 }
378
379 /**
380 * @tc.name:StopDownloadFileTest
381 * @tc.desc:Verify the StopDownloadFile function.
382 * @tc.type:FUNC
383 * @tc.require: I6H5MH
384 */
385 HWTEST_F(CloudSyncServiceTest, StopDownloadFileTest, TestSize.Level1)
386 {
387 GTEST_LOG_(INFO) << "StopDownloadFile start";
388 try {
389 int64_t downloadId = 0;
390 bool needClean = false;
391 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
392 int ret = servicePtr_->StopDownloadFile(downloadId, needClean);
393 EXPECT_EQ(E_PERMISSION_DENIED, ret);
394 } catch (...) {
395 EXPECT_TRUE(false);
396 GTEST_LOG_(INFO) << "StopDownloadFile FAILED";
397 }
398 GTEST_LOG_(INFO) << "StopDownloadFile end";
399 }
400
401 /**
402 * @tc.name:UploadAssetTest
403 * @tc.desc:Verify the UploadAsset function.
404 * @tc.type:FUNC
405 * @tc.require: I6H5MH
406 */
407 HWTEST_F(CloudSyncServiceTest, UploadAssetTest, TestSize.Level1)
408 {
409 GTEST_LOG_(INFO) << "UploadAsset start";
410 try {
411 int32_t userId = 100;
412 std::string request = "testReq";
413 std::string result = "expRes";
414 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
415 int ret = servicePtr_->UploadAsset(userId, request, result);
416 EXPECT_EQ(ret, E_PERMISSION_DENIED);
417 } catch (...) {
418 EXPECT_TRUE(false);
419 GTEST_LOG_(INFO) << "UploadAsset FAILED";
420 }
421 GTEST_LOG_(INFO) << "UploadAsset end";
422 }
423
424 /**
425 * @tc.name:DownloadFileTest001
426 * @tc.desc:Verify the DownloadFile function.
427 * @tc.type:FUNC
428 * @tc.require: I6H5MH
429 */
430 HWTEST_F(CloudSyncServiceTest, DownloadFileTest001, TestSize.Level1)
431 {
432 GTEST_LOG_(INFO) << "DownloadFileTest001 start";
433 try {
434 int32_t userId = 100;
435 std::string bundleName = "com.ohos.photos";
436 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
437 AssetInfoObj assetInfoObj;
438 assetInfoObj.uri = uri;
439 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
440 int ret = servicePtr_->DownloadFile(userId, bundleName, assetInfoObj);
441 EXPECT_EQ(ret, E_PERMISSION_DENIED);
442 } catch (...) {
443 EXPECT_TRUE(false);
444 GTEST_LOG_(INFO) << "DownloadFileTest001 FAILED";
445 }
446 GTEST_LOG_(INFO) << "DownloadFileTest001 end";
447 }
448
449 /**
450 * @tc.name:DownloadAssetTest001
451 * @tc.desc:Verify the DownloadAsset function.
452 * @tc.type:FUNC
453 * @tc.require: I6H5MH
454 */
455 HWTEST_F(CloudSyncServiceTest, DownloadAssetTest001, TestSize.Level1)
456 {
457 GTEST_LOG_(INFO) << "DownloadAssetTest001 start";
458 try {
459 uint64_t taskId = 100;
460 int32_t userId = 100;
461 std::string bundleName = "com.ohos.photos";
462 std::string networkId = "0.0.0.0";
463 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
464 AssetInfoObj assetInfoObj;
465 assetInfoObj.uri = uri;
466 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
467 int ret = servicePtr_->DownloadAsset(taskId, userId, bundleName, networkId, assetInfoObj);
468 EXPECT_EQ(ret, E_PERMISSION_DENIED);
469 } catch (...) {
470 EXPECT_TRUE(false);
471 GTEST_LOG_(INFO) << "DownloadAssetTest001 FAILED";
472 }
473 GTEST_LOG_(INFO) << "DownloadAssetTest001 end";
474 }
475
476 /**
477 * @tc.name:DownloadAssetTest002
478 * @tc.desc:Verify the DownloadAsset function.
479 * @tc.type:FUNC
480 * @tc.require: I6H5MH
481 */
482 HWTEST_F(CloudSyncServiceTest, DownloadAssetTest002, TestSize.Level1)
483 {
484 GTEST_LOG_(INFO) << "DownloadAssetTest002 start";
485 try {
486 uint64_t taskId = 100;
487 int32_t userId = 100;
488 std::string bundleName = "com.ohos.photos";
489 std::string networkId = "edge2cloud";
490 AssetInfoObj assetInfoObj;
491 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
492 int ret = servicePtr_->DownloadAsset(taskId, userId, bundleName, networkId, assetInfoObj);
493 EXPECT_EQ(ret, E_PERMISSION_DENIED);
494 } catch (...) {
495 EXPECT_TRUE(false);
496 GTEST_LOG_(INFO) << "DownloadAssetTest002 FAILED";
497 }
498 GTEST_LOG_(INFO) << "DownloadAssetTest002 end";
499 }
500
501 /**
502 * @tc.name:RegisterDownloadAssetCallbackTest
503 * @tc.desc:Verify the RegisterDownloadAssetCallback function.
504 * @tc.type:FUNC
505 * @tc.require: I6H5MH
506 */
507 HWTEST_F(CloudSyncServiceTest, RegisterDownloadAssetCallbackTest, TestSize.Level1)
508 {
509 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback start";
510 try {
511 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
512 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
513 int ret = servicePtr_->RegisterDownloadAssetCallback(callback);
514 EXPECT_EQ(ret, E_PERMISSION_DENIED);
515 } catch (...) {
516 EXPECT_TRUE(false);
517 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback FAILED";
518 }
519 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback end";
520 }
521
522 /**
523 * @tc.name:RegisterDownloadAssetCallbackTest002
524 * @tc.desc:Verify theRegisterDownloadAssetCallback function.
525 * @tc.type:FUNC
526 * @tc.require: I6H5MH
527 */
528 HWTEST_F(CloudSyncServiceTest, RegisterDownloadAssetCallbackTest002, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback error branch start";
531 try {
532 sptr<CloudSyncCallbackMock> callback = nullptr;
533 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
534 int ret = servicePtr_->RegisterDownloadAssetCallback(callback);
535 EXPECT_EQ(ret, E_PERMISSION_DENIED);
536 } catch (...) {
537 EXPECT_TRUE(false);
538 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback error branch FAILED";
539 }
540 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback error branch end";
541 }
542
543 /**
544 * @tc.name:DeleteAssetTest001
545 * @tc.desc:Verify the DeleteAsset function.
546 * @tc.type:FUNC
547 * @tc.require: I6H5MH
548 */
549 HWTEST_F(CloudSyncServiceTest, DeleteAssetTest001, TestSize.Level1)
550 {
551 GTEST_LOG_(INFO) << "DeleteAssetTest001 start";
552 try {
553 int32_t userId = 100;
554 std::string uri = "";
555 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
556 int ret = servicePtr_->DeleteAsset(userId, uri);
557 EXPECT_EQ(ret, E_PERMISSION_DENIED);
558 } catch (...) {
559 EXPECT_TRUE(false);
560 GTEST_LOG_(INFO) << "DeleteAssetTest001 FAILED";
561 }
562 GTEST_LOG_(INFO) << "DeleteAssetTest001 end";
563 }
564
565 /**
566 * @tc.name:DeleteAssetTest002
567 * @tc.desc:Verify the DeleteAsset function.
568 * @tc.type:FUNC
569 * @tc.require: I6H5MH
570 */
571 HWTEST_F(CloudSyncServiceTest, DeleteAssetTest002, TestSize.Level1)
572 {
573 GTEST_LOG_(INFO) << "DeleteAssetTest002 start";
574 try {
575 int32_t userId = 100;
576 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
577 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
578 int ret = servicePtr_->DeleteAsset(userId, uri);
579 EXPECT_EQ(ret, E_PERMISSION_DENIED);
580 } catch (...) {
581 EXPECT_TRUE(false);
582 GTEST_LOG_(INFO) << "DeleteAssetTest002 FAILED";
583 }
584 GTEST_LOG_(INFO) << "DeleteAssetTest002 end";
585 }
586
587 /**
588 * @tc.name:GetHmdfsPathTest001
589 * @tc.desc:Verify the GetHmdfsPath function.
590 * @tc.type:FUNC
591 * @tc.require: I6H5MH
592 */
593 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest001, TestSize.Level1)
594 {
595 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 start";
596 try {
597 std::string uri = "";
598 int32_t userId = 100;
599 std::string ret = servicePtr_->GetHmdfsPath(uri, userId);
600 EXPECT_EQ(ret, "");
601 } catch (...) {
602 EXPECT_TRUE(false);
603 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 FAILED";
604 }
605 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 end";
606 }
607
608 /**
609 * @tc.name:GetHmdfsPathTest002
610 * @tc.desc:Verify the GetHmdfsPath function.
611 * @tc.type:FUNC
612 * @tc.require: I6H5MH
613 */
614 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest002, TestSize.Level1)
615 {
616 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 start";
617 try {
618 std::string uri = "invaild_uri";
619 int32_t userId = 100;
620 std::string ret = servicePtr_->GetHmdfsPath(uri, userId);
621 EXPECT_EQ(ret, "");
622 } catch (...) {
623 EXPECT_TRUE(false);
624 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 FAILED";
625 }
626 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 end";
627 }
628
629 /**
630 * @tc.name:GetHmdfsPathTest003
631 * @tc.desc:Verify the GetHmdfsPath function.
632 * @tc.type:FUNC
633 * @tc.require: I6H5MH
634 */
635 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest003, TestSize.Level1)
636 {
637 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 start";
638 try {
639 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1...txt";
640 int32_t userId = 100;
641 std::string ret = servicePtr_->GetHmdfsPath(uri, userId);
642 std::string out = "/mnt/hmdfs/100/account/device_view/local/data/com.hmos.notepad/dir/1...txt";
643 EXPECT_EQ(ret, out);
644 } catch (...) {
645 EXPECT_TRUE(false);
646 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 FAILED";
647 }
648 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 end";
649 }
650
651 /**
652 * @tc.name:GetHmdfsPathTest004
653 * @tc.desc:Verify the GetHmdfsPath function.
654 * @tc.type:FUNC
655 * @tc.require: I6H5MH
656 */
657 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest004, TestSize.Level1)
658 {
659 GTEST_LOG_(INFO) << "GetHmdfsPathTest004 start";
660 try {
661 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/../../dir/1.txt";
662 int32_t userId = 100;
663 std::string ret = servicePtr_->GetHmdfsPath(uri, userId);
664 EXPECT_EQ(ret, "");
665 } catch (...) {
666 EXPECT_TRUE(false);
667 GTEST_LOG_(INFO) << "GetHmdfsPathTest004 FAILED";
668 }
669 GTEST_LOG_(INFO) << "GetHmdfsPathTest004 end";
670 }
671
672 /**
673 * @tc.name: OnStopTest
674 * @tc.desc: Verify the OnStop function.
675 * @tc.type: FUNC
676 * @tc.require: I6H5MH
677 */
678 HWTEST_F(CloudSyncServiceTest, OnStopTest, TestSize.Level1)
679 {
680 GTEST_LOG_(INFO) << "OnStop start";
681 try {
682 servicePtr_->OnStop();
683 } catch (...) {
684 EXPECT_TRUE(false);
685 GTEST_LOG_(INFO) << "OnStop FAILED";
686 }
687 GTEST_LOG_(INFO) << "OnStop end";
688 }
689
690 /**
691 * @tc.name: OnAddSystemAbilityTest
692 * @tc.desc: Verify the OnAddSystemAbility function.
693 * @tc.type: FUNC
694 * @tc.require: I6H5MH
695 */
696 HWTEST_F(CloudSyncServiceTest, OnAddSystemAbilityTest, TestSize.Level1)
697 {
698 GTEST_LOG_(INFO) << "OnAddSystemAbility start";
699 try {
700 int32_t systemAbilityId = 100;
701 std::string deviceId = "";
702 servicePtr_->OnAddSystemAbility(systemAbilityId, deviceId);
703 } catch (...) {
704 EXPECT_TRUE(false);
705 GTEST_LOG_(INFO) << "OnAddSystemAbility FAILED";
706 }
707 GTEST_LOG_(INFO) << "OnAddSystemAbility end";
708 }
709
710 /**
711 * @tc.name: OnAddSystemAbilityTest002
712 * @tc.desc: Verify the OnAddSystemAbility function.
713 * @tc.type: FUNC
714 * @tc.require: I6H5MH
715 */
716 HWTEST_F(CloudSyncServiceTest, OnAddSystemAbilityTest002, TestSize.Level1)
717 {
718 GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 start";
719 try {
720 int32_t MEMORY_MANAGER_SA_ID = 1909;
721 int32_t systemAbilityId = MEMORY_MANAGER_SA_ID;
722 std::string deviceId = "";
723 servicePtr_->OnAddSystemAbility(systemAbilityId, deviceId);
724 } catch (...) {
725 EXPECT_TRUE(false);
726 GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 FAILED";
727 }
728 GTEST_LOG_(INFO) << "OnAddSystemAbilityTest002 end";
729 }
730
731 /**
732 * @tc.name: LoadRemoteSATest001
733 * @tc.desc: Verify the LoadRemoteSA function.
734 * @tc.type: FUNC
735 * @tc.require: I6H5MH
736 */
737 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest001, TestSize.Level1)
738 {
739 GTEST_LOG_(INFO) << "LoadRemoteSATest001 start";
740 try {
741 std::string deviceId = "";
742 int ret = servicePtr_->LoadRemoteSA(deviceId);
743 EXPECT_EQ(ret, E_SA_LOAD_FAILED);
744 } catch (...) {
745 EXPECT_TRUE(false);
746 GTEST_LOG_(INFO) << "LoadRemoteSATest001 FAILED";
747 }
748 GTEST_LOG_(INFO) << "LoadRemoteSATest001 end";
749 }
750
751 /**
752 * @tc.name: LoadRemoteSATest002
753 * @tc.desc: Verify the LoadRemoteSA function.
754 * @tc.type: FUNC
755 * @tc.require: I6H5MH
756 */
757 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest002, TestSize.Level1)
758 {
759 GTEST_LOG_(INFO) << "LoadRemoteSATest002 start";
760 try {
761 std::string deviceId = "abc123";
762 EXPECT_CALL(*saMgrClient_, GetSystemAbilityManager()).WillOnce(Return(nullptr));
763 int ret = servicePtr_->LoadRemoteSA(deviceId);
764 EXPECT_EQ(ret, E_SA_LOAD_FAILED);
765 } catch (...) {
766 EXPECT_TRUE(false);
767 GTEST_LOG_(INFO) << "LoadRemoteSATest002 FAILED";
768 }
769 GTEST_LOG_(INFO) << "LoadRemoteSATest002 end";
770 }
771
772 /**
773 * @tc.name: LoadRemoteSATest003
774 * @tc.desc: Verify the LoadRemoteSA function.
775 * @tc.type: FUNC
776 * @tc.require: I6H5MH
777 */
778 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest003, TestSize.Level1)
779 {
780 GTEST_LOG_(INFO) << "LoadRemoteSATest003 start";
781 try {
782 std::string deviceId = "abc123";
783 sptr<CloudDownloadCallbackMock> downloadCallback = sptr(new CloudDownloadCallbackMock());
784 servicePtr_->remoteObjectMap_.insert(std::make_pair(deviceId, downloadCallback));
785 int ret = servicePtr_->LoadRemoteSA(deviceId);
786 servicePtr_->remoteObjectMap_.clear();
787 EXPECT_EQ(ret, E_OK);
788 } catch (...) {
789 EXPECT_TRUE(false);
790 GTEST_LOG_(INFO) << "LoadRemoteSATest003 FAILED";
791 }
792 GTEST_LOG_(INFO) << "LoadRemoteSATest003 end";
793 }
794
795 /**
796 * @tc.name: LoadRemoteSATest004
797 * @tc.desc: Verify the LoadRemoteSA function.
798 * @tc.type: FUNC
799 * @tc.require: I6H5MH
800 */
801 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest004, TestSize.Level1)
802 {
803 GTEST_LOG_(INFO) << "LoadRemoteSATest004 start";
804 try {
805 std::string deviceId = "abcd1234";
806 EXPECT_CALL(*saMgrClient_, GetSystemAbilityManager()).WillOnce(Return(saMgr_));
807 sptr<CloudDownloadCallbackMock> downloadCallback = sptr(new CloudDownloadCallbackMock());
808 EXPECT_CALL(*saMgr_, CheckSystemAbility(An<int32_t>(), An<const string &>()))
809 .WillOnce(Return(downloadCallback));
810 servicePtr_->remoteObjectMap_.clear();
811 int ret = servicePtr_->LoadRemoteSA(deviceId);
812 EXPECT_EQ(ret, E_OK);
813 } catch (...) {
814 EXPECT_TRUE(false);
815 GTEST_LOG_(INFO) << "LoadRemoteSATest004 FAILED";
816 }
817 GTEST_LOG_(INFO) << "LoadRemoteSATest004 end";
818 }
819
820 /**
821 * @tc.name: LoadRemoteSATest005
822 * @tc.desc: Verify the LoadRemoteSA function.
823 * @tc.type: FUNC
824 * @tc.require: I6H5MH
825 */
826 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest005, TestSize.Level1)
827 {
828 GTEST_LOG_(INFO) << "LoadRemoteSATest005 start";
829 try {
830 std::string deviceId = "abcde12345";
831 EXPECT_CALL(*saMgrClient_, GetSystemAbilityManager()).WillOnce(Return(saMgr_));
832 EXPECT_CALL(*saMgr_, CheckSystemAbility(An<int32_t>(), An<const string &>())).WillOnce(Return(nullptr));
833 int ret = servicePtr_->LoadRemoteSA(deviceId);
834 servicePtr_->remoteObjectMap_.clear();
835 EXPECT_EQ(ret, E_SA_LOAD_FAILED);
836 } catch (...) {
837 EXPECT_TRUE(false);
838 GTEST_LOG_(INFO) << "LoadRemoteSATest005 FAILED";
839 }
840 GTEST_LOG_(INFO) << "LoadRemoteSATest005 end";
841 }
842
843 /**
844 * @tc.name: LoadRemoteSATest006
845 * @tc.desc: Verify the LoadRemoteSA function.
846 * @tc.type: FUNC
847 * @tc.require: I6H5MH
848 */
849 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest006, TestSize.Level1)
850 {
851 GTEST_LOG_(INFO) << "LoadRemoteSATest006 start";
852 try {
853 std::string deviceId = "abcdef123456";
854 EXPECT_CALL(*saMgrClient_, GetSystemAbilityManager()).WillOnce(Return(saMgr_));
855 servicePtr_->remoteObjectMap_.insert(std::make_pair(deviceId, nullptr));
856 EXPECT_CALL(*saMgr_, CheckSystemAbility(An<int32_t>(), An<const string &>())).WillOnce(Return(nullptr));
857 int ret = servicePtr_->LoadRemoteSA(deviceId);
858 servicePtr_->remoteObjectMap_.clear();
859 EXPECT_EQ(ret, E_SA_LOAD_FAILED);
860 } catch (...) {
861 EXPECT_TRUE(false);
862 GTEST_LOG_(INFO) << "LoadRemoteSATest006 FAILED";
863 }
864 GTEST_LOG_(INFO) << "LoadRemoteSATest006 end";
865 }
866
867 /**
868 * @tc.name: LoadRemoteSATest007
869 * @tc.desc: Verify the LoadRemoteSA function.
870 * @tc.type: FUNC
871 * @tc.require: I6H5MH
872 */
873 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest007, TestSize.Level1)
874 {
875 GTEST_LOG_(INFO) << "LoadRemoteSATest007 start";
876 try {
877 std::string deviceId = "abcdefg1234567";
878 EXPECT_CALL(*saMgrClient_, GetSystemAbilityManager()).WillOnce(Return(saMgr_)).WillOnce(Return(saMgr_));
879 servicePtr_->remoteObjectMap_.insert(std::make_pair(deviceId, nullptr));
880 sptr<CloudDownloadCallbackMock> downloadCallback = sptr(new CloudDownloadCallbackMock());
881 EXPECT_CALL(*saMgr_, CheckSystemAbility(An<int32_t>(), An<const string &>()))
882 .WillOnce(Return(downloadCallback));
883 int ret = servicePtr_->LoadRemoteSA(deviceId);
884 servicePtr_->remoteObjectMap_.clear();
885 EXPECT_EQ(ret, E_OK);
886 } catch (...) {
887 EXPECT_TRUE(false);
888 GTEST_LOG_(INFO) << "LoadRemoteSATest007 FAILED";
889 }
890 GTEST_LOG_(INFO) << "LoadRemoteSATest007 end";
891 }
892
893 /**
894 * @tc.name:SetDeathRecipientTest001
895 * @tc.desc:Verify the SetDeathRecipient function.
896 * @tc.type:FUNC
897 * @tc.require: IB3SLT
898 */
899 HWTEST_F(CloudSyncServiceTest, SetDeathRecipientTest001, TestSize.Level1)
900 {
901 GTEST_LOG_(INFO) << "SetDeathRecipientTest001 start";
902 try {
903 EXPECT_NE(servicePtr_, nullptr);
904 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
905 servicePtr_->SetDeathRecipient(callback);
906 } catch (...) {
907 EXPECT_TRUE(false);
908 GTEST_LOG_(INFO) << "SetDeathRecipientTest001 failed";
909 }
910 GTEST_LOG_(INFO) << "SetDeathRecipientTest001 end";
911 }
912
913 /**
914 * @tc.name: HandleStartReasonTest001
915 * @tc.desc: Verify the HandleStartReason function.
916 * @tc.type: FUNC
917 * @tc.require: IB3SLT
918 */
919 HWTEST_F(CloudSyncServiceTest, HandleStartReasonTest001, TestSize.Level1)
920 {
921 GTEST_LOG_(INFO) << "HandleStartReasonTest001 start";
922 try {
923 EXPECT_NE(servicePtr_, nullptr);
924 SystemAbilityOnDemandReason startReason;
925 startReason.reasonName_ = "load";
926 servicePtr_->HandleStartReason(startReason);
927 } catch (...) {
928 EXPECT_TRUE(false);
929 GTEST_LOG_(INFO) << "HandleStartReason failed";
930 }
931 GTEST_LOG_(INFO) << "HandleStartReasonTest001 end";
932 }
933
934 /**
935 * @tc.name: HandleStartReasonTest002
936 * @tc.desc: Verify the HandleStartReason function.
937 * @tc.type: FUNC
938 * @tc.require: IB3SLT
939 */
940 HWTEST_F(CloudSyncServiceTest, HandleStartReasonTest002, TestSize.Level1)
941 {
942 GTEST_LOG_(INFO) << "HandleStartReasonTest002 start";
943 try {
944 EXPECT_NE(servicePtr_, nullptr);
945 EXPECT_CALL(*saMgrClient_, GetSystemAbilityManager()).WillRepeatedly(Return(nullptr));
946 SystemAbilityOnDemandReason startReason;
947 startReason.reasonName_ = "usual.event.SCREEN_OFF";
948 servicePtr_->HandleStartReason(startReason);
949 } catch (...) {
950 EXPECT_TRUE(false);
951 GTEST_LOG_(INFO) << "HandleStartReasonTest002 failed";
952 }
953 GTEST_LOG_(INFO) << "HandleStartReasonTest002 end";
954 }
955
956 /**
957 * @tc.name: HandleStartReasonTest003
958 * @tc.desc: Verify the HandleStartReason function.
959 * @tc.type: FUNC
960 * @tc.require: IB3SLT
961 */
962 HWTEST_F(CloudSyncServiceTest, HandleStartReasonTest003, TestSize.Level1)
963 {
964 GTEST_LOG_(INFO) << "HandleStartReasonTest003 start";
965 try {
966 EXPECT_NE(servicePtr_, nullptr);
967 EXPECT_CALL(*saMgrClient_, GetSystemAbilityManager()).WillRepeatedly(Return(nullptr));
968 SystemAbilityOnDemandReason startReason;
969 startReason.reasonName_ = "usual.event.POWER_CONNECTED";
970 servicePtr_->HandleStartReason(startReason);
971 } catch (...) {
972 EXPECT_TRUE(false);
973 GTEST_LOG_(INFO) << "HandleStartReasonTest003 failed";
974 }
975 GTEST_LOG_(INFO) << "HandleStartReasonTest003 end";
976 }
977
978 /**
979 * @tc.name: InitTest001
980 * @tc.desc: Verify the Init function.
981 * @tc.type: FUNC
982 * @tc.require: IB3SLT
983 */
984 HWTEST_F(CloudSyncServiceTest, InitTest001, TestSize.Level1)
985 {
986 GTEST_LOG_(INFO) << "InitTest001 start";
987 try {
988 EXPECT_NE(servicePtr_, nullptr);
989 servicePtr_->Init();
990 } catch (...) {
991 EXPECT_TRUE(false);
992 GTEST_LOG_(INFO) << "InitTest001 failed";
993 }
994 GTEST_LOG_(INFO) << "InitTest001 end";
995 }
996
997 /**
998 * @tc.name: GetBundleNameUserInfoTest001
999 * @tc.desc: Verify the GetBundleNameUserInfo function.
1000 * @tc.type: FUNC
1001 * @tc.require: IB3SLT
1002 */
1003 HWTEST_F(CloudSyncServiceTest, GetBundleNameUserInfoTest001, TestSize.Level1)
1004 {
1005 GTEST_LOG_(INFO) << "GetBundleNameUserInfoTest001 start";
1006 try {
1007 EXPECT_NE(servicePtr_, nullptr);
1008 BundleNameUserInfo userInfo;
1009 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_INVAL_ARG));
1010 int32_t ret = servicePtr_->GetBundleNameUserInfo(userInfo);
1011 EXPECT_EQ(ret, E_INVAL_ARG);
1012 } catch (...) {
1013 EXPECT_TRUE(false);
1014 GTEST_LOG_(INFO) << "GetBundleNameUserInfoTest001 failed";
1015 }
1016 GTEST_LOG_(INFO) << "GetBundleNameUserInfoTest001 end";
1017 }
1018
1019 /**
1020 * @tc.name: GetBundleNameUserInfoTest002
1021 * @tc.desc: Verify the GetBundleNameUserInfo function.
1022 * @tc.type: FUNC
1023 * @tc.require: IB3SLT
1024 */
1025 HWTEST_F(CloudSyncServiceTest, GetBundleNameUserInfoTest002, TestSize.Level1)
1026 {
1027 GTEST_LOG_(INFO) << "GetBundleNameUserInfoTest002 start";
1028 try {
1029 EXPECT_NE(servicePtr_, nullptr);
1030 std::vector<std::string> uriVec = {""};
1031 BundleNameUserInfo userInfo;
1032 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1033 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1034 servicePtr_->GetBundleNameUserInfo(uriVec, userInfo);
1035 EXPECT_EQ(userInfo.userId, 100);
1036 EXPECT_EQ(userInfo.pid, 101);
1037 } catch (...) {
1038 EXPECT_TRUE(false);
1039 GTEST_LOG_(INFO) << "GetBundleNameUserInfoTest002 failed";
1040 }
1041 GTEST_LOG_(INFO) << "GetBundleNameUserInfoTest002 end";
1042 }
1043
1044 /**
1045 * @tc.name: StartDowngradeTest002
1046 * @tc.desc: Verify the StartDowngrade function.
1047 * @tc.type: FUNC
1048 * @tc.require: #NA
1049 */
1050 HWTEST_F(CloudSyncServiceTest, StartDowngradeTest002, TestSize.Level1)
1051 {
1052 GTEST_LOG_(INFO) << "StartDowngradeTest002 start";
1053 try {
1054 EXPECT_NE(servicePtr_, nullptr);
1055 std::string bundleName = "com.ohos.aaa";
1056 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1057 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1058 sptr<DowngradeDlCallbackMock> callback = sptr(new DowngradeDlCallbackMock());
1059 auto ret = servicePtr_->StartDowngrade(bundleName, callback);
1060 EXPECT_EQ(ret, E_OK);
1061 } catch (...) {
1062 EXPECT_TRUE(false);
1063 GTEST_LOG_(INFO) << "StartDowngradeTest002 failed";
1064 }
1065 GTEST_LOG_(INFO) << "StartDowngradeTest002 end";
1066 }
1067
1068 /**
1069 * @tc.name: StopDowngradeTest001
1070 * @tc.desc: Verify the StopDowngrade function.
1071 * @tc.type: FUNC
1072 * @tc.require: #NA
1073 */
1074 HWTEST_F(CloudSyncServiceTest, StopDowngradeTest001, TestSize.Level1)
1075 {
1076 GTEST_LOG_(INFO) << "StopDowngradeTest001 start";
1077 try {
1078 EXPECT_NE(servicePtr_, nullptr);
1079 std::string bundleName = "com.ohos.aaa";
1080 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1081 auto ret = servicePtr_->StopDowngrade(bundleName);
1082 EXPECT_NE(ret, E_OK);
1083 } catch (...) {
1084 EXPECT_TRUE(false);
1085 GTEST_LOG_(INFO) << "StopDowngradeTest001 failed";
1086 }
1087 GTEST_LOG_(INFO) << "StopDowngradeTest001 end";
1088 }
1089
1090 /**
1091 * @tc.name: StopDowngradeTest002
1092 * @tc.desc: Verify the StopDowngrade function.
1093 * @tc.type: FUNC
1094 * @tc.require: #NA
1095 */
1096 HWTEST_F(CloudSyncServiceTest, StopDowngradeTest002, TestSize.Level1)
1097 {
1098 GTEST_LOG_(INFO) << "StopDowngradeTest002 start";
1099 try {
1100 EXPECT_NE(servicePtr_, nullptr);
1101 std::string bundleName = "com.ohos.aaa";
1102 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1103 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1104 auto ret = servicePtr_->StopDowngrade(bundleName);
1105 EXPECT_EQ(ret, E_OK);
1106 } catch (...) {
1107 EXPECT_TRUE(false);
1108 GTEST_LOG_(INFO) << "StopDowngradeTest002 failed";
1109 }
1110 GTEST_LOG_(INFO) << "StopDowngradeTest002 end";
1111 }
1112
1113 /**
1114 * @tc.name: GetCloudFileInfoTest001
1115 * @tc.desc: Verify the GetCloudFileInfo function.
1116 * @tc.type: FUNC
1117 * @tc.require: #NA
1118 */
1119 HWTEST_F(CloudSyncServiceTest, GetCloudFileInfoTest001, TestSize.Level1)
1120 {
1121 GTEST_LOG_(INFO) << "GetCloudFileInfoTest001 start";
1122 try {
1123 EXPECT_NE(servicePtr_, nullptr);
1124 std::string bundleName = "com.ohos.aaa";
1125 CloudFileInfo cloudFileInfo;
1126 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1127 auto ret = servicePtr_->GetCloudFileInfo(bundleName, cloudFileInfo);
1128 EXPECT_NE(ret, E_OK);
1129 } catch (...) {
1130 EXPECT_TRUE(false);
1131 GTEST_LOG_(INFO) << "GetCloudFileInfoTest001 failed";
1132 }
1133 GTEST_LOG_(INFO) << "GetCloudFileInfoTest001 end";
1134 }
1135
1136 /**
1137 * @tc.name: GetCloudFileInfoTest002
1138 * @tc.desc: Verify the GetCloudFileInfo function.
1139 * @tc.type: FUNC
1140 * @tc.require: #NA
1141 */
1142 HWTEST_F(CloudSyncServiceTest, GetCloudFileInfoTest002, TestSize.Level1)
1143 {
1144 GTEST_LOG_(INFO) << "GetCloudFileInfoTest002 start";
1145 try {
1146 EXPECT_NE(servicePtr_, nullptr);
1147 std::string bundleName = "com.ohos.aaa";
1148 CloudFileInfo cloudFileInfo;
1149 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1150 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1151 auto ret = servicePtr_->GetCloudFileInfo(bundleName, cloudFileInfo);
1152 EXPECT_EQ(ret, E_OK);
1153 } catch (...) {
1154 EXPECT_TRUE(false);
1155 GTEST_LOG_(INFO) << "GetCloudFileInfoTest002 failed";
1156 }
1157 GTEST_LOG_(INFO) << "GetCloudFileInfoTest002 end";
1158 }
1159
1160 /**
1161 * @tc.name: GetHistoryVersionList001
1162 * @tc.desc: Verify the GetHistoryVersionList function.
1163 * @tc.type: FUNC
1164 * @tc.require: ICGORT
1165 */
1166 HWTEST_F(CloudSyncServiceTest, GetHistoryVersionList001, TestSize.Level1)
1167 {
1168 GTEST_LOG_(INFO) << "GetHistoryVersionList001 start";
1169 try {
1170 EXPECT_NE(servicePtr_, nullptr);
1171 string uri;
1172 int32_t numLimit = 0;
1173 vector<HistoryVersion> historyVersionList;
1174 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_INVAL_ARG));
1175 auto ret = servicePtr_->GetHistoryVersionList(uri, numLimit, historyVersionList);
1176 EXPECT_NE(ret, E_OK);
1177
1178 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1179 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1180 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1181 ret = servicePtr_->GetHistoryVersionList(uri, numLimit, historyVersionList);
1182 EXPECT_EQ(ret, E_OK);
1183 } catch (...) {
1184 EXPECT_TRUE(false);
1185 GTEST_LOG_(INFO) << "GetHistoryVersionList001 failed";
1186 }
1187 GTEST_LOG_(INFO) << "GetHistoryVersionList001 end";
1188 }
1189
1190 /**
1191 * @tc.name: DownloadHistoryVersion001
1192 * @tc.desc: Verify the DownloadHistoryVersion function.
1193 * @tc.type: FUNC
1194 * @tc.require: ICGORT
1195 */
1196 HWTEST_F(CloudSyncServiceTest, DownloadHistoryVersion001, TestSize.Level1)
1197 {
1198 GTEST_LOG_(INFO) << "DownloadHistoryVersion001 start";
1199 try {
1200 EXPECT_NE(servicePtr_, nullptr);
1201 string uri;
1202 int64_t downloadId = 0;
1203 uint64_t versionId = 0;
1204 sptr<CloudDownloadCallbackMock> callback = sptr(new CloudDownloadCallbackMock());
1205 string versionUri;
1206 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_INVAL_ARG));
1207 auto ret = servicePtr_->DownloadHistoryVersion(uri, downloadId, versionId, callback, versionUri);
1208 EXPECT_NE(ret, E_OK);
1209
1210 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1211 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1212 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1213 ret = servicePtr_->DownloadHistoryVersion(uri, downloadId, versionId, callback, versionUri);
1214 EXPECT_EQ(ret, E_OK);
1215 } catch (...) {
1216 EXPECT_TRUE(false);
1217 GTEST_LOG_(INFO) << "DownloadHistoryVersion001 failed";
1218 }
1219 GTEST_LOG_(INFO) << "DownloadHistoryVersion001 end";
1220 }
1221
1222 /**
1223 * @tc.name: ReplaceFileWithHistoryVersion001
1224 * @tc.desc: Verify the ReplaceFileWithHistoryVersion function.
1225 * @tc.type: FUNC
1226 * @tc.require: ICGORT
1227 */
1228 HWTEST_F(CloudSyncServiceTest, ReplaceFileWithHistoryVersion001, TestSize.Level1)
1229 {
1230 GTEST_LOG_(INFO) << "ReplaceFileWithHistoryVersion001 start";
1231 try {
1232 EXPECT_NE(servicePtr_, nullptr);
1233 string oriUri;
1234 string uri;
1235 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_INVAL_ARG));
1236 auto ret = servicePtr_->ReplaceFileWithHistoryVersion(oriUri, uri);
1237 EXPECT_NE(ret, E_OK);
1238
1239 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1240 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1241 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1242 ret = servicePtr_->ReplaceFileWithHistoryVersion(oriUri, uri);
1243 EXPECT_EQ(ret, E_OK);
1244 } catch (...) {
1245 EXPECT_TRUE(false);
1246 GTEST_LOG_(INFO) << "ReplaceFileWithHistoryVersion001 failed";
1247 }
1248 GTEST_LOG_(INFO) << "ReplaceFileWithHistoryVersion001 end";
1249 }
1250
1251 /**
1252 * @tc.name: IsFileConflict001
1253 * @tc.desc: Verify the IsFileConflict function.
1254 * @tc.type: FUNC
1255 * @tc.require: ICGORT
1256 */
1257 HWTEST_F(CloudSyncServiceTest, IsFileConflict001, TestSize.Level1)
1258 {
1259 GTEST_LOG_(INFO) << "IsFileConflict001 start";
1260 try {
1261 EXPECT_NE(servicePtr_, nullptr);
1262 string uri;
1263 bool isConflict;
1264 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_INVAL_ARG));
1265 auto ret = servicePtr_->IsFileConflict(uri, isConflict);
1266 EXPECT_NE(ret, E_OK);
1267
1268 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1269 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1270 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1271 ret = servicePtr_->IsFileConflict(uri, isConflict);
1272 EXPECT_EQ(ret, E_OK);
1273 } catch (...) {
1274 EXPECT_TRUE(false);
1275 GTEST_LOG_(INFO) << "IsFileConflict001 failed";
1276 }
1277 GTEST_LOG_(INFO) << "IsFileConflict001 end";
1278 }
1279
1280 /**
1281 * @tc.name: ClearFileConflict001
1282 * @tc.desc: Verify the ClearFileConflict function.
1283 * @tc.type: FUNC
1284 * @tc.require: ICGORT
1285 */
1286 HWTEST_F(CloudSyncServiceTest, ClearFileConflict001, TestSize.Level1)
1287 {
1288 GTEST_LOG_(INFO) << "ClearFileConflict001 start";
1289 try {
1290 EXPECT_NE(servicePtr_, nullptr);
1291 string uri;
1292 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_INVAL_ARG));
1293 auto ret = servicePtr_->ClearFileConflict(uri);
1294 EXPECT_NE(ret, E_OK);
1295
1296 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1297 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1298 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1299 ret = servicePtr_->ClearFileConflict(uri);
1300 EXPECT_EQ(ret, E_OK);
1301 } catch (...) {
1302 EXPECT_TRUE(false);
1303 GTEST_LOG_(INFO) << "ClearFileConflict001 failed";
1304 }
1305 GTEST_LOG_(INFO) << "ClearFileConflict001 end";
1306 }
1307
1308 /**
1309 * @tc.name: CleanFileCacheInner001
1310 * @tc.desc: Verify the CleanFileCacheInner001 function.
1311 * @tc.type: FUNC
1312 * @tc.require: ICK6VD
1313 */
1314 HWTEST_F(CloudSyncServiceTest, CleanFileCacheInner001, TestSize.Level1)
1315 {
1316 GTEST_LOG_(INFO) << "CleanFileCacheInner001 start";
1317 try {
1318 EXPECT_NE(servicePtr_, nullptr);
1319 string uri;
1320 EXPECT_CALL(*dfsuAccessToken_, CheckUriPermission(_)).WillOnce(Return(false));
1321 auto ret = servicePtr_->CleanFileCacheInner(uri);
1322 EXPECT_EQ(ret, E_ILLEGAL_URI);
1323 } catch (...) {
1324 EXPECT_FALSE(true);
1325 GTEST_LOG_(INFO) << "CleanFileCacheInner001 failed";
1326 }
1327 GTEST_LOG_(INFO) << "CleanFileCacheInner001 end";
1328 }
1329
1330 /**
1331 * @tc.name: CleanFileCacheInner002
1332 * @tc.desc: Verify the CleanFileCacheInner002 function.
1333 * @tc.type: FUNC
1334 * @tc.require: ICK6VD
1335 */
1336 HWTEST_F(CloudSyncServiceTest, CleanFileCacheInner002, TestSize.Level1)
1337 {
1338 GTEST_LOG_(INFO) << "CleanFileCacheInner002 start";
1339 try {
1340 EXPECT_NE(servicePtr_, nullptr);
1341 string uri;
1342 EXPECT_CALL(*dfsuAccessToken_, CheckUriPermission(_)).WillOnce(Return(true));
1343 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_ILLEGAL_URI));
1344 auto ret = servicePtr_->CleanFileCacheInner(uri);
1345 EXPECT_EQ(ret, E_SERVICE_INNER_ERROR);
1346 } catch (...) {
1347 EXPECT_FALSE(true);
1348 GTEST_LOG_(INFO) << "CleanFileCacheInner002 failed";
1349 }
1350 GTEST_LOG_(INFO) << "CleanFileCacheInner002 end";
1351 }
1352
1353 /**
1354 * @tc.name: CleanFileCacheInner003
1355 * @tc.desc: Verify the CleanFileCacheInner003 function.
1356 * @tc.type: FUNC
1357 * @tc.require: ICK6VD
1358 */
1359 HWTEST_F(CloudSyncServiceTest, CleanFileCacheInner003, TestSize.Level1)
1360 {
1361 GTEST_LOG_(INFO) << "CleanFileCacheInner003 start";
1362 try {
1363 EXPECT_NE(servicePtr_, nullptr);
1364 string uri;
1365 EXPECT_CALL(*dfsuAccessToken_, CheckUriPermission(_)).WillOnce(Return(true));
1366 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1367 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1368 auto ret = servicePtr_->CleanFileCacheInner(uri);
1369 EXPECT_EQ(ret, E_OK);
1370 } catch (...) {
1371 EXPECT_FALSE(true);
1372 GTEST_LOG_(INFO) << "CleanFileCacheInner003 failed";
1373 }
1374 GTEST_LOG_(INFO) << "CleanFileCacheInner003 end";
1375 }
1376
1377 /**
1378 * @tc.name: StartFileCacheTest001
1379 * @tc.desc: Verify the StartFileCache function.
1380 * @tc.type: FUNC
1381 * @tc.require: ICK6VD
1382 */
1383 HWTEST_F(CloudSyncServiceTest, StartFileCacheTest001, TestSize.Level1)
1384 {
1385 GTEST_LOG_(INFO) << "StartFileCacheTest001 start";
1386 try {
1387 EXPECT_NE(servicePtr_, nullptr);
1388 string uri;
1389 int64_t downloadId = 0;
1390 int32_t fieldkey = 0;
1391 int32_t timeout = -1;
1392 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
1393 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1394 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1395 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1396 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1397 auto ret = servicePtr_->StartFileCache({uri}, downloadId, fieldkey, callback, timeout);
1398 EXPECT_EQ(ret, E_BROKEN_IPC);
1399 } catch (...) {
1400 EXPECT_FALSE(true);
1401 GTEST_LOG_(INFO) << "StartFileCacheTest001 failed";
1402 }
1403 GTEST_LOG_(INFO) << "StartFileCacheTest001 end";
1404 }
1405
1406 /**
1407 * @tc.name: StartFileCacheTest002
1408 * @tc.desc: Verify the StartFileCache function.
1409 * @tc.type: FUNC
1410 * @tc.require: ICK6VD
1411 */
1412 HWTEST_F(CloudSyncServiceTest, StartFileCacheTest002, TestSize.Level1)
1413 {
1414 GTEST_LOG_(INFO) << "StartFileCacheTest002 start";
1415 try {
1416 EXPECT_NE(servicePtr_, nullptr);
1417 string uri;
1418 int64_t downloadId = 0;
1419 int32_t fieldkey = 0;
1420 int32_t timeout = -1;
1421 sptr<CloudDownloadCallbackMock> downloadCallback = sptr(new CloudDownloadCallbackMock());
1422 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1423 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1424 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1425 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1426 auto ret = servicePtr_->StartFileCache({uri}, downloadId, fieldkey, downloadCallback, timeout);
1427 EXPECT_EQ(ret, E_OK);
1428 } catch (...) {
1429 EXPECT_FALSE(true);
1430 GTEST_LOG_(INFO) << "StartFileCacheTest002 failed";
1431 }
1432 GTEST_LOG_(INFO) << "StartFileCacheTest002 end";
1433 }
1434
1435 /**
1436 * @tc.name: StartDownloadFileTest001
1437 * @tc.desc: Verify the StartDownloadFile function.
1438 * @tc.type: FUNC
1439 * @tc.require: ICK6VD
1440 */
1441 HWTEST_F(CloudSyncServiceTest, StartDownloadFileTest001, TestSize.Level1)
1442 {
1443 GTEST_LOG_(INFO) << "StartDownloadFileTest001 start";
1444 try {
1445 EXPECT_NE(servicePtr_, nullptr);
1446 string uri;
1447 int64_t downloadId = 0;
1448 sptr<CloudDownloadCallbackMock> downloadCallback = sptr(new CloudDownloadCallbackMock());
1449 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1450 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1451 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1452 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1453 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1454 auto ret = servicePtr_->StartDownloadFile(uri, downloadCallback, downloadId);
1455 EXPECT_EQ(ret, E_OK);
1456 } catch (...) {
1457 EXPECT_FALSE(true);
1458 GTEST_LOG_(INFO) << "StartDownloadFileTest001 failed";
1459 }
1460 GTEST_LOG_(INFO) << "StartDownloadFileTest001 end";
1461 }
1462
1463 /**
1464 * @tc.name: StartDownloadFileTest002
1465 * @tc.desc: Verify the StartDownloadFile function.
1466 * @tc.type: FUNC
1467 * @tc.require: ICK6VD
1468 */
1469 HWTEST_F(CloudSyncServiceTest, StartDownloadFileTest002, TestSize.Level1)
1470 {
1471 GTEST_LOG_(INFO) << "StartDownloadFileTest002 start";
1472 try {
1473 EXPECT_NE(servicePtr_, nullptr);
1474 string uri;
1475 int64_t downloadId = 0;
1476 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
1477 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1478 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1479 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1480 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1481 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1482 auto ret = servicePtr_->StartDownloadFile(uri, callback, downloadId);
1483 EXPECT_EQ(ret, E_INVAL_ARG);
1484 } catch (...) {
1485 EXPECT_FALSE(true);
1486 GTEST_LOG_(INFO) << "StartDownloadFileTest002 failed";
1487 }
1488 GTEST_LOG_(INFO) << "StartDownloadFileTest002 end";
1489 }
1490
1491 /**
1492 * @tc.name: StopFileCacheTest001
1493 * @tc.desc: Verify the StopFileCache function.
1494 * @tc.type: FUNC
1495 * @tc.require: ICK6VD
1496 */
1497 HWTEST_F(CloudSyncServiceTest, StopFileCacheTest001, TestSize.Level1)
1498 {
1499 GTEST_LOG_(INFO) << "StopFileCacheTest001 start";
1500 try {
1501 EXPECT_NE(servicePtr_, nullptr);
1502 int64_t downloadId = 0;
1503 bool needClean = false;
1504 int32_t timeout = -1;
1505 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1506 EXPECT_CALL(*dfsuAccessToken_, GetCallerBundleName(_)).WillOnce(Return(E_OK));
1507 EXPECT_CALL(*dfsuAccessToken_, GetUserId()).WillOnce(Return(0));
1508 EXPECT_CALL(*dfsuAccessToken_, GetPid()).WillOnce(Return(101));
1509 auto ret = servicePtr_->StopFileCache(downloadId, needClean, timeout);
1510 EXPECT_EQ(ret, E_OK);
1511 } catch (...) {
1512 EXPECT_FALSE(true);
1513 GTEST_LOG_(INFO) << "StopFileCacheTest001 failed";
1514 }
1515 GTEST_LOG_(INFO) << "StopFileCacheTest001 end";
1516 }
1517
1518 /**
1519 * @tc.name: DownloadFilesTest001
1520 * @tc.desc: Verify the DownloadFiles function.
1521 * @tc.type: FUNC
1522 * @tc.require: NA
1523 */
1524 HWTEST_F(CloudSyncServiceTest, DownloadFilesTest001, TestSize.Level1)
1525 {
1526 GTEST_LOG_(INFO) << "DownloadFilesTest001 start";
1527 try {
1528 EXPECT_NE(servicePtr_, nullptr);
1529 int32_t userId = 100;
1530 const std::string bundleName = "com.ohos.test";
1531 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
1532 AssetInfoObj assetInfoObj;
1533 assetInfoObj.uri = uri;
1534 std::vector<AssetInfoObj> assetInfoObjs;
1535 assetInfoObjs.push_back(assetInfoObj);
1536 std::vector<bool> assetResultMap;
1537 assetResultMap.push_back(true);
1538 int32_t connectTime = 1;
1539
1540 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1541 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1542
1543 CloudFile::CloudFileKit::instance_ = nullptr;
1544
1545 auto ret = servicePtr_->DownloadFiles(userId, bundleName, assetInfoObjs, assetResultMap, connectTime);
1546 EXPECT_EQ(ret, E_NULLPTR);
1547 CloudFile::CloudFileKit::instance_ = new (std::nothrow) CloudFileKit();
1548 } catch (...) {
1549 EXPECT_FALSE(true);
1550 GTEST_LOG_(INFO) << "DownloadFilesTest001 failed";
1551 }
1552 GTEST_LOG_(INFO) << "DownloadFilesTest001 end";
1553 }
1554
1555 /**
1556 * @tc.name: DownloadFilesTest002
1557 * @tc.desc: Verify the DownloadFiles function.
1558 * @tc.type: FUNC
1559 * @tc.require: NA
1560 */
1561 HWTEST_F(CloudSyncServiceTest, DownloadFilesTest002, TestSize.Level1)
1562 {
1563 GTEST_LOG_(INFO) << "DownloadFilesTest002 start";
1564 try {
1565 EXPECT_NE(servicePtr_, nullptr);
1566 int32_t userId = 100;
1567 const std::string bundleName = "com.ohos.test";
1568 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
1569 AssetInfoObj assetInfoObj;
1570 assetInfoObj.uri = uri;
1571 std::vector<AssetInfoObj> assetInfoObjs;
1572 assetInfoObjs.push_back(assetInfoObj);
1573 std::vector<bool> assetResultMap;
1574 assetResultMap.push_back(true);
1575 int32_t connectTime = 1;
1576 auto cloudFileKitMock = new (std::nothrow) CloudFileKitMock();
1577 CloudFile::CloudFileKit::instance_ = cloudFileKitMock;
1578
1579 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1580 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1581 EXPECT_CALL(*cloudFileKitMock, GetCloudAssetsDownloader(_, _)).WillOnce(Return(nullptr));
1582
1583 auto ret = servicePtr_->DownloadFiles(userId, bundleName, assetInfoObjs, assetResultMap, connectTime);
1584 EXPECT_EQ(ret, E_NULLPTR);
1585 } catch (...) {
1586 EXPECT_FALSE(true);
1587 GTEST_LOG_(INFO) << "DownloadFilesTest002 failed";
1588 }
1589 GTEST_LOG_(INFO) << "DownloadFilesTest002 end";
1590 }
1591
1592 /**
1593 * @tc.name: DownloadFilesTest003
1594 * @tc.desc: Verify the DownloadFiles function.
1595 * @tc.type: FUNC
1596 * @tc.require: NA
1597 */
1598 HWTEST_F(CloudSyncServiceTest, DownloadFilesTest003, TestSize.Level1)
1599 {
1600 GTEST_LOG_(INFO) << "DownloadFilesTest003 start";
1601 try {
1602 EXPECT_NE(servicePtr_, nullptr);
1603 int32_t userId = 100;
1604 const std::string bundleName = "com.ohos.test";
1605 std::string uri = "";
1606 AssetInfoObj assetInfoObj;
1607 assetInfoObj.uri = uri;
1608 std::vector<AssetInfoObj> assetInfoObjs;
1609 assetInfoObjs.push_back(assetInfoObj);
1610 std::vector<bool> assetResultMap;
1611 assetResultMap.push_back(true);
1612 int32_t connectTime = 1;
1613 auto cloudFileKitMock = new (std::nothrow) CloudFileKitMock();
1614 CloudFile::CloudFileKit::instance_ = cloudFileKitMock;
1615
1616 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1617 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1618 EXPECT_CALL(*cloudFileKitMock, GetCloudAssetsDownloader(_, _)).WillOnce(
1619 Return(make_shared<CloudAssetsDownloader>(userId, bundleName)));
1620
1621 auto ret = servicePtr_->DownloadFiles(userId, bundleName, assetInfoObjs, assetResultMap, connectTime);
1622 EXPECT_EQ(ret, E_INVAL_ARG);
1623 } catch (...) {
1624 EXPECT_FALSE(true);
1625 GTEST_LOG_(INFO) << "DownloadFilesTest003 failed";
1626 }
1627 GTEST_LOG_(INFO) << "DownloadFilesTest003 end";
1628 }
1629 } // namespace Test
1630 } // namespace FileManagement::CloudSync
1631 } // namespace OHOS
1632