1 /*
2 * Copyright (c) 2023 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 #include <memory>
18
19 #include "cloud_sync_service_proxy.h"
20 #include "dfs_error.h"
21 #include "i_cloud_download_callback_mock.h"
22 #include "i_cloud_sync_service_mock.h"
23 #include "service_callback_mock.h"
24
25 namespace OHOS {
26 namespace FileManagement::CloudSync {
27 namespace Test {
28 using namespace testing::ext;
29 using namespace testing;
30 using namespace std;
31
32 class CloudSyncServiceProxyTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 shared_ptr<CloudSyncServiceProxy> proxy_ = nullptr;
39 sptr<CloudSyncServiceMock> mock_ = nullptr;
40 sptr<CloudSyncCallbackMock> remote_ = nullptr;
41 sptr<CloudDownloadCallbackMock> download_ = nullptr;
42 };
43
SetUpTestCase(void)44 void CloudSyncServiceProxyTest::SetUpTestCase(void)
45 {
46 std::cout << "SetUpTestCase" << std::endl;
47 }
48
TearDownTestCase(void)49 void CloudSyncServiceProxyTest::TearDownTestCase(void)
50 {
51 std::cout << "TearDownTestCase" << std::endl;
52 }
53
SetUp(void)54 void CloudSyncServiceProxyTest::SetUp(void)
55 {
56 mock_ = sptr(new CloudSyncServiceMock());
57 proxy_ = make_shared<CloudSyncServiceProxy>(mock_);
58 remote_ = sptr(new CloudSyncCallbackMock());
59 download_ = sptr(new CloudDownloadCallbackMock());
60 std::cout << "SetUp" << std::endl;
61 }
62
TearDown(void)63 void CloudSyncServiceProxyTest::TearDown(void)
64 {
65 proxy_ = nullptr;
66 mock_ = nullptr;
67 remote_ = nullptr;
68 std::cout << "TearDown" << std::endl;
69 }
70
71 /**
72 * @tc.name: UnRegisterCallbackInner001
73 * @tc.desc: Verify the UnRegisterCallbackInner function.
74 * @tc.type: FUNC
75 * @tc.require: issueI7UYAL
76 */
77 HWTEST_F(CloudSyncServiceProxyTest, UnRegisterCallbackInner001, TestSize.Level1)
78 {
79 GTEST_LOG_(INFO) << "UnRegisterCallbackInner Start";
80 string bundleName = "com.ohos.photos";
81 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
82 int result = proxy_->UnRegisterCallbackInner(bundleName);
83 EXPECT_EQ(result, E_BROKEN_IPC);
84 GTEST_LOG_(INFO) << "UnRegisterCallbackInner End";
85 }
86
87 /**
88 * @tc.name: UnRegisterCallbackInner002
89 * @tc.desc: Verify the RRegisterCallbackInner function.
90 * @tc.type: FUNC
91 * @tc.require: issueI7UYAL
92 */
93 HWTEST_F(CloudSyncServiceProxyTest, UnRegisterCallbackInner002, TestSize.Level1)
94 {
95 GTEST_LOG_(INFO) << "UnRegisterCallbackInner Start";
96 string bundleName = "com.ohos.photos";
97 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
98 int result = proxy_->UnRegisterCallbackInner(bundleName);
99 EXPECT_EQ(result, E_OK);
100 GTEST_LOG_(INFO) << "UnRegisterCallbackInner End";
101 }
102
103
104 /**
105 * @tc.name: RegisterCallbackInner001
106 * @tc.desc: Verify the RegisterCallbackInner function.
107 * @tc.type: FUNC
108 * @tc.require: issueI7UYAL
109 */
110 HWTEST_F(CloudSyncServiceProxyTest, RegisterCallbackInner001, TestSize.Level1)
111 {
112 GTEST_LOG_(INFO) << "RegisterCallbackInner Start";
113 string bundleName = "com.ohos.photos";
114
115 int result = proxy_->RegisterCallbackInner(nullptr, bundleName);
116 EXPECT_EQ(result, E_INVAL_ARG);
117 GTEST_LOG_(INFO) << "RegisterCallbackInner End";
118 }
119
120 /**
121 * @tc.name: RegisterCallbackInner002
122 * @tc.desc: Verify the RegisterCallbackInner function.
123 * @tc.type: FUNC
124 * @tc.require: I6H5MH
125 */
126 HWTEST_F(CloudSyncServiceProxyTest, RegisterCallbackInner002, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "RegisterCallbackInner Start";
129 string bundleName = "com.ohos.photos";
130 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
131
132 int result = proxy_->RegisterCallbackInner(remote_, bundleName);
133 EXPECT_EQ(result, E_BROKEN_IPC);
134 GTEST_LOG_(INFO) << "RegisterCallbackInner End";
135 }
136
137 /**
138 * @tc.name: RegisterCallbackInner003
139 * @tc.desc: Verify the RegisterCallbackInner function.
140 * @tc.type: FUNC
141 * @tc.require: I6H5MH
142 */
143 HWTEST_F(CloudSyncServiceProxyTest, RegisterCallbackInner003, TestSize.Level1)
144 {
145 GTEST_LOG_(INFO) << "RegisterCallbackInner Start";
146 string bundleName = "com.ohos.photos";
147 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
148
149 int result = proxy_->RegisterCallbackInner(remote_, bundleName);
150 EXPECT_EQ(result, E_OK);
151 GTEST_LOG_(INFO) << "RegisterCallbackInner End";
152 }
153
154 /**
155 * @tc.name: StartSyncInner001
156 * @tc.desc: Verify the StartSyncInner function.
157 * @tc.type: FUNC
158 * @tc.require: I6H5MH
159 */
160 HWTEST_F(CloudSyncServiceProxyTest, StartSyncInner001, TestSize.Level1)
161 {
162 GTEST_LOG_(INFO) << "StartSyncInner Start";
163 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
164
165 bool forceFlag = true;
166 int result = proxy_->StartSyncInner(forceFlag);
167 EXPECT_EQ(result, E_BROKEN_IPC);
168 GTEST_LOG_(INFO) << "StartSyncInner End";
169 }
170
171 /**
172 * @tc.name: StartSyncInner002
173 * @tc.desc: Verify the StartSyncInner function.
174 * @tc.type: FUNC
175 * @tc.require: I6H5MH
176 */
177 HWTEST_F(CloudSyncServiceProxyTest, StartSyncInner002, TestSize.Level1)
178 {
179 GTEST_LOG_(INFO) << "StartSyncInner Start";
180 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
181 .Times(2)
182 .WillOnce(Invoke(mock_.GetRefPtr(), &CloudSyncServiceMock::InvokeSendRequest))
183 .WillOnce(Return(EPERM));
184
185 bool forceFlag = true;
186 int result = proxy_->StartSyncInner(forceFlag);
187 EXPECT_EQ(result, E_OK);
188
189 result = proxy_->StartSyncInner(forceFlag);
190 EXPECT_NE(result, E_OK);
191 GTEST_LOG_(INFO) << "StartSyncInner End";
192 }
193
194 /**
195 * @tc.name: TriggerSyncInnerInner001
196 * @tc.desc: Verify the TriggerSyncInner function.
197 * @tc.type: FUNC
198 * @tc.require: I6H5MH
199 */
200 HWTEST_F(CloudSyncServiceProxyTest, TriggerSyncInner001, TestSize.Level1)
201 {
202 GTEST_LOG_(INFO) << "TriggerSyncInner Start";
203 string bundleName = "com.ohos.photos";
204 int32_t userId = 100;
205 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
206
207 int result = proxy_->TriggerSyncInner(bundleName, userId);
208 EXPECT_EQ(result, E_BROKEN_IPC);
209 GTEST_LOG_(INFO) << "TriggerSyncInner End";
210 }
211
212 /**
213 * @tc.name: TriggerSyncInner002
214 * @tc.desc: Verify the TriggerSyncInner function.
215 * @tc.type: FUNC
216 * @tc.require: I6H5MH
217 */
218 HWTEST_F(CloudSyncServiceProxyTest, TriggerSyncInner002, TestSize.Level1)
219 {
220 GTEST_LOG_(INFO) << "TriggerSyncInner Start";
221 string bundleName = "com.ohos.photos";
222 int32_t userId = 100;
223 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
224
225 int result = proxy_->TriggerSyncInner(bundleName, userId);
226 EXPECT_EQ(result, E_OK);
227 GTEST_LOG_(INFO) << "TriggerSyncInner End";
228 }
229
230 /**
231 * @tc.name: GetSyncTimeInner001
232 * @tc.desc: Verify the GetSyncTimeInner function.
233 * @tc.type: FUNC
234 * @tc.require: I6H5MH
235 */
236 HWTEST_F(CloudSyncServiceProxyTest, GetSyncTimeInner001, TestSize.Level1)
237 {
238 GTEST_LOG_(INFO) << "GetSyncTimeInner Start";
239 string bundleName = "com.ohos.photos";
240 int64_t syncTime = 0;
241 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
242
243 int result = proxy_->GetSyncTimeInner(syncTime, bundleName);
244 EXPECT_EQ(result, E_BROKEN_IPC);
245 GTEST_LOG_(INFO) << "GetSyncTimeInner End";
246 }
247
248 /**
249 * @tc.name: GetSyncTimeInner002
250 * @tc.desc: Verify the GetSyncTimeInner function.
251 * @tc.type: FUNC
252 * @tc.require: I6H5MH
253 */
254 HWTEST_F(CloudSyncServiceProxyTest, GetSyncTimeInner002, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "GetSyncTimeInner Start";
257 string bundleName = "com.ohos.photos";
258 int64_t syncTime = 0;
259 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
260
261 int result = proxy_->GetSyncTimeInner(syncTime, bundleName);
262 EXPECT_EQ(result, E_OK);
263 GTEST_LOG_(INFO) << "GetSyncTimeInner End";
264 }
265
266 /**
267 * @tc.name: CleanCacheInner001
268 * @tc.desc: Verify the CleanCacheInner function.
269 * @tc.type: FUNC
270 * @tc.require: I6H5MH
271 */
272 HWTEST_F(CloudSyncServiceProxyTest, CleanCacheInner001, TestSize.Level1)
273 {
274 GTEST_LOG_(INFO) << "CleanCacheInner Start";
275 string uri = "";
276 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
277
278 int result = proxy_->CleanCacheInner(uri);
279 EXPECT_EQ(result, E_BROKEN_IPC);
280 GTEST_LOG_(INFO) << "CleanCacheInner End";
281 }
282
283 /**
284 * @tc.name: CleanCacheInner002
285 * @tc.desc: Verify the CleanCacheInner function.
286 * @tc.type: FUNC
287 * @tc.require: I6H5MH
288 */
289 HWTEST_F(CloudSyncServiceProxyTest, CleanCacheInner002, TestSize.Level1)
290 {
291 GTEST_LOG_(INFO) << "CleanCacheInner Start";
292 string uri = "";
293 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
294
295 int result = proxy_->CleanCacheInner(uri);
296 EXPECT_EQ(result, E_OK);
297 GTEST_LOG_(INFO) << "CleanCacheInner End";
298 }
299
300 /**
301 * @tc.name: StopSyncInner001
302 * @tc.desc: Verify the StopSyncInner function.
303 * @tc.type: FUNC
304 * @tc.require: I6H5MH
305 */
306 HWTEST_F(CloudSyncServiceProxyTest, StopSyncInner001, TestSize.Level1)
307 {
308 GTEST_LOG_(INFO) << "StopSyncInner Start";
309 string bundleName = "com.ohos.photos";
310 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
311
312 int result = proxy_->StopSyncInner(bundleName);
313 EXPECT_EQ(result, E_BROKEN_IPC);
314 GTEST_LOG_(INFO) << "StopSyncInner End";
315 }
316
317 /**
318 * @tc.name: StopSyncInner002
319 * @tc.desc: Verify the StopSyncInner function.
320 * @tc.type: FUNC
321 * @tc.require: I6H5MH
322 */
323 HWTEST_F(CloudSyncServiceProxyTest, StopSyncInner002, TestSize.Level1)
324 {
325 GTEST_LOG_(INFO) << "StopSyncInner Start";
326 string bundleName = "com.ohos.photos";
327 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
328
329 int result = proxy_->StopSyncInner(bundleName);
330 EXPECT_EQ(result, E_OK);
331 GTEST_LOG_(INFO) << "StopSyncInner End";
332 }
333
334 /**
335 * @tc.name: ChangeAppSwitch001
336 * @tc.desc: Verify the ChangeAppSwitch function.
337 * @tc.type: FUNC
338 * @tc.require: I6H5MH
339 */
340 HWTEST_F(CloudSyncServiceProxyTest, ChangeAppSwitch001, TestSize.Level1)
341 {
342 GTEST_LOG_(INFO) << "ChangeAppSwitch Start";
343 string accoutId = "100";
344 string bundleName = "com.ohos.photos";
345 bool status = true;
346 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
347
348 int result = proxy_->ChangeAppSwitch(accoutId, bundleName, status);
349 EXPECT_EQ(result, E_BROKEN_IPC);
350 GTEST_LOG_(INFO) << "ChangeAppSwitch End";
351 }
352
353 /**
354 * @tc.name: ChangeAppSwitch002
355 * @tc.desc: Verify the ChangeAppSwitch function.
356 * @tc.type: FUNC
357 * @tc.require: I6H5MH
358 */
359 HWTEST_F(CloudSyncServiceProxyTest, ChangeAppSwitch002, TestSize.Level1)
360 {
361 GTEST_LOG_(INFO) << "ChangeAppSwitch Start";
362 string accoutId = "100";
363 string bundleName = "com.ohos.photos";
364 bool status = true;
365 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
366
367 int result = proxy_->ChangeAppSwitch(accoutId, bundleName, status);
368 EXPECT_EQ(result, E_OK);
369 GTEST_LOG_(INFO) << "ChangeAppSwitch End";
370 }
371
372 /**
373 * @tc.name: Clean001
374 * @tc.desc: Verify the Clean function.
375 * @tc.type: FUNC
376 * @tc.require: I6H5MH
377 */
378 HWTEST_F(CloudSyncServiceProxyTest, Clean001, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "Clean Start";
381 string accoutId = "100";
382 CleanOptions cleanOptions;
383 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
384
385 int result = proxy_->Clean(accoutId, cleanOptions);
386 EXPECT_EQ(result, E_BROKEN_IPC);
387 GTEST_LOG_(INFO) << "Clean End";
388 }
389
390 /**
391 * @tc.name: Clean002
392 * @tc.desc: Verify the Clean function.
393 * @tc.type: FUNC
394 * @tc.require: I6H5MH
395 */
396 HWTEST_F(CloudSyncServiceProxyTest, Clean002, TestSize.Level1)
397 {
398 GTEST_LOG_(INFO) << "Clean Start";
399 string accoutId = "100";
400 CleanOptions cleanOptions;
401 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
402
403 int result = proxy_->Clean(accoutId, cleanOptions);
404 EXPECT_EQ(result, E_OK);
405 GTEST_LOG_(INFO) << "Clean End";
406 }
407
408 /**
409 * @tc.name: EnableCloud001
410 * @tc.desc: Verify the EnableCloud function.
411 * @tc.type: FUNC
412 * @tc.require: I6H5MH
413 */
414 HWTEST_F(CloudSyncServiceProxyTest, EnableCloud001, TestSize.Level1)
415 {
416 GTEST_LOG_(INFO) << "EnableCloud Start";
417 string accoutId = "100";
418 SwitchDataObj switchData;
419 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
420
421 int result = proxy_->EnableCloud(accoutId, switchData);
422 EXPECT_EQ(result, E_BROKEN_IPC);
423 GTEST_LOG_(INFO) << "EnableCloud End";
424 }
425
426 /**
427 * @tc.name: EnableCloud002
428 * @tc.desc: Verify the EnableCloud function.
429 * @tc.type: FUNC
430 * @tc.require: I6H5MH
431 */
432 HWTEST_F(CloudSyncServiceProxyTest, EnableCloud002, TestSize.Level1)
433 {
434 GTEST_LOG_(INFO) << "EnableCloud Start";
435 string accoutId = "100";
436 SwitchDataObj switchData;
437 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
438
439 int result = proxy_->EnableCloud(accoutId, switchData);
440 EXPECT_EQ(result, E_OK);
441 GTEST_LOG_(INFO) << "EnableCloud End";
442 }
443
444 /**
445 * @tc.name: DisableCloud001
446 * @tc.desc: Verify the DisableCloud function.
447 * @tc.type: FUNC
448 * @tc.require: I6H5MH
449 */
450 HWTEST_F(CloudSyncServiceProxyTest, DisableCloud001, TestSize.Level1)
451 {
452 GTEST_LOG_(INFO) << "DisableCloud Start";
453 string accoutId = "100";
454 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
455
456 int result = proxy_->DisableCloud(accoutId);
457 EXPECT_EQ(result, E_BROKEN_IPC);
458 GTEST_LOG_(INFO) << "DisableCloud End";
459 }
460
461 /**
462 * @tc.name: DisableCloud002
463 * @tc.desc: Verify the DisableCloud function.
464 * @tc.type: FUNC
465 * @tc.require: I6H5MH
466 */
467 HWTEST_F(CloudSyncServiceProxyTest, DisableCloud002, TestSize.Level1)
468 {
469 GTEST_LOG_(INFO) << "DisableCloud Start";
470 string accoutId = "100";
471 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
472
473 int result = proxy_->DisableCloud(accoutId);
474 EXPECT_EQ(result, E_OK);
475 GTEST_LOG_(INFO) << "DisableCloud End";
476 }
477
478 /**
479 * @tc.name: NotifyDataChange001
480 * @tc.desc: Verify the NotifyDataChange function.
481 * @tc.type: FUNC
482 * @tc.require: I6H5MH
483 */
484 HWTEST_F(CloudSyncServiceProxyTest, NotifyDataChange001, TestSize.Level1)
485 {
486 GTEST_LOG_(INFO) << "NotifyDataChange Start";
487 string accoutId = "100";
488 string bundleName = "com.ohos.photos";
489 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
490
491 int result = proxy_->NotifyDataChange(accoutId, bundleName);
492 EXPECT_EQ(result, E_BROKEN_IPC);
493 GTEST_LOG_(INFO) << "NotifyDataChange End";
494 }
495
496 /**
497 * @tc.name: NotifyDataChange002
498 * @tc.desc: Verify the NotifyDataChange function.
499 * @tc.type: FUNC
500 * @tc.require: I6H5MH
501 */
502 HWTEST_F(CloudSyncServiceProxyTest, NotifyDataChange002, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO) << "NotifyDataChange Start";
505 string accoutId = "100";
506 string bundleName = "com.ohos.photos";
507 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
508
509 int result = proxy_->NotifyDataChange(accoutId, bundleName);
510 EXPECT_EQ(result, E_OK);
511 GTEST_LOG_(INFO) << "NotifyDataChange End";
512 }
513
514 /**
515 * @tc.name: NotifyEventChange001
516 * @tc.desc: Verify the NotifyEventChange function.
517 * @tc.type: FUNC
518 * @tc.require: I6H5MH
519 */
520 HWTEST_F(CloudSyncServiceProxyTest, NotifyEventChange001, TestSize.Level1)
521 {
522 GTEST_LOG_(INFO) << "NotifyEventChange Start";
523 int32_t userId = 100;
524 string eventId = "";
525 string extraData = "";
526 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
527
528 int result = proxy_->NotifyEventChange(userId, eventId, extraData);
529 EXPECT_EQ(result, E_BROKEN_IPC);
530 GTEST_LOG_(INFO) << "NotifyEventChange End";
531 }
532
533 /**
534 * @tc.name: NotifyEventChange002
535 * @tc.desc: Verify the NotifyEventChange function.
536 * @tc.type: FUNC
537 * @tc.require: I6H5MH
538 */
539 HWTEST_F(CloudSyncServiceProxyTest, NotifyEventChange002, TestSize.Level1)
540 {
541 GTEST_LOG_(INFO) << "NotifyEventChange Start";
542 int32_t userId = 100;
543 string eventId = "";
544 string extraData = "";
545 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
546
547 int result = proxy_->NotifyEventChange(userId, eventId, extraData);
548 EXPECT_EQ(result, E_OK);
549 GTEST_LOG_(INFO) << "NotifyEventChange End";
550 }
551
552
553 /**
554 * @tc.name: StartDownloadFile001
555 * @tc.desc: Verify the StartDownloadFile function.
556 * @tc.type: FUNC
557 * @tc.require: I6H5MH
558 */
559 HWTEST_F(CloudSyncServiceProxyTest, StartDownloadFile001, TestSize.Level1)
560 {
561 GTEST_LOG_(INFO) << "StartDownloadFile Start";
562 string uri = "";
563 int result = proxy_->StartDownloadFile(uri);
564 EXPECT_EQ(result, E_OK);
565 GTEST_LOG_(INFO) << "StartDownloadFile End";
566 }
567
568 /**
569 * @tc.name: StartFileCache001
570 * @tc.desc: Verify the StartFileCache function.
571 * @tc.type: FUNC
572 * @tc.require: I6H5MH
573 */
574 HWTEST_F(CloudSyncServiceProxyTest, StartFileCache001, TestSize.Level1)
575 {
576 GTEST_LOG_(INFO) << "StartFileCache Start";
577 string uri = "";
578 std::vector<std::string> uriVec;
579 uriVec.push_back(uri);
580 int64_t downloadId = 0;
581 int result = proxy_->StartFileCache(uriVec, downloadId);
582 EXPECT_EQ(result, E_OK);
583 GTEST_LOG_(INFO) << "StartFileCache End";
584 }
585
586 /**
587 * @tc.name: StopDownloadFile001
588 * @tc.desc: Verify the StopDownloadFile function.
589 * @tc.type: FUNC
590 * @tc.require: I6H5MH
591 */
592 HWTEST_F(CloudSyncServiceProxyTest, StopDownloadFile001, TestSize.Level1)
593 {
594 GTEST_LOG_(INFO) << "StopDownloadFile Start";
595 string uri = "file://media";
596 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
597
598 int result = proxy_->StopDownloadFile(uri);
599 EXPECT_EQ(result, E_BROKEN_IPC);
600 GTEST_LOG_(INFO) << "StopDownloadFile End";
601 }
602
603 /**
604 * @tc.name: StopDownloadFile002
605 * @tc.desc: Verify the StopDownloadFile function.
606 * @tc.type: FUNC
607 * @tc.require: I6H5MH
608 */
609 HWTEST_F(CloudSyncServiceProxyTest, StopDownloadFile002, TestSize.Level1)
610 {
611 GTEST_LOG_(INFO) << "StopDownloadFile Start";
612 string uri = "";
613 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
614
615 int result = proxy_->StopDownloadFile(uri);
616 EXPECT_EQ(result, E_OK);
617 GTEST_LOG_(INFO) << "StopDownloadFile End";
618 }
619
620 /**
621 * @tc.name: UploadAsset001
622 * @tc.desc: Verify the UploadAsset function.
623 * @tc.type: FUNC
624 * @tc.require: I6H5MH
625 */
626 HWTEST_F(CloudSyncServiceProxyTest, UploadAsset001, TestSize.Level1)
627 {
628 GTEST_LOG_(INFO) << "UploadAsset001 Start";
629 int32_t userId = 100;
630 string request = "test_request";
631 string result;
632 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
633 int ret = proxy_->UploadAsset(userId, request, result);
634 EXPECT_EQ(ret, E_BROKEN_IPC);
635 GTEST_LOG_(INFO) << "UploadAsset001 End";
636 }
637
638 /**
639 * @tc.name: UploadAsset002
640 * @tc.desc: Verify the UploadAsset function.
641 * @tc.type: FUNC
642 * @tc.require: I6H5MH
643 */
644 HWTEST_F(CloudSyncServiceProxyTest, UploadAsset002, TestSize.Level1)
645 {
646 GTEST_LOG_(INFO) << "UploadAsset002 Start";
647 int32_t userId = 100;
648 string request = "test_request";
649 string result;
650 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
651 int ret = proxy_->UploadAsset(userId, request, result);
652 EXPECT_EQ(ret, E_OK);
653 GTEST_LOG_(INFO) << "UploadAsset002 End";
654 }
655
656 /**
657 * @tc.name: DownloadFile001
658 * @tc.desc: Verify the DownloadFile function.
659 * @tc.type: FUNC
660 * @tc.require: I6H5MH
661 */
662 HWTEST_F(CloudSyncServiceProxyTest, DownloadFile001, TestSize.Level1)
663 {
664 GTEST_LOG_(INFO) << "DownloadFile001 Start";
665 int32_t userId = 100;
666 string bundleName = "com.ohos.photos";
667 AssetInfoObj assetInfoObj;
668 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
669 int ret = proxy_->DownloadFile(userId, bundleName, assetInfoObj);
670 EXPECT_EQ(ret, E_BROKEN_IPC);
671 GTEST_LOG_(INFO) << "DownloadFile001 End";
672 }
673
674 /**
675 * @tc.name: DownloadFile002
676 * @tc.desc: Verify the DownloadFile function.
677 * @tc.type: FUNC
678 * @tc.require: I6H5MH
679 */
680 HWTEST_F(CloudSyncServiceProxyTest, DownloadFile002, TestSize.Level1)
681 {
682 GTEST_LOG_(INFO) << "DownloadFile002 Start";
683 int32_t userId = 100;
684 string bundleName = "com.ohos.photos";
685 AssetInfoObj assetInfoObj;
686 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
687 int ret = proxy_->DownloadFile(userId, bundleName, assetInfoObj);
688 EXPECT_EQ(ret, E_OK);
689 GTEST_LOG_(INFO) << "DownloadFile002 End";
690 }
691
692 /**
693 * @tc.name: DownloadFiles001
694 * @tc.desc: Verify the DownloadFiles function.
695 * @tc.type: FUNC
696 * @tc.require: I6H5MH
697 */
698 HWTEST_F(CloudSyncServiceProxyTest, DownloadFiles001, TestSize.Level1)
699 {
700 GTEST_LOG_(INFO) << "DownloadFiles001 Start";
701 int32_t userId = 100;
702 string bundleName = "com.ohos.photos";
703 std::vector<AssetInfoObj> assetInfoObj;
704 std::vector<bool> assetResultMap;
705 int ret = proxy_->DownloadFiles(userId, bundleName, assetInfoObj, assetResultMap);
706 EXPECT_EQ(ret, E_INVAL_ARG);
707 GTEST_LOG_(INFO) << "DownloadFiles001 End";
708 }
709
710 /**
711 * @tc.name: DownloadFiles002
712 * @tc.desc: Verify the DownloadFiles function.
713 * @tc.type: FUNC
714 * @tc.require: I6H5MH
715 */
716 HWTEST_F(CloudSyncServiceProxyTest, DownloadFiles002, TestSize.Level1)
717 {
718 GTEST_LOG_(INFO) << "DownloadFiles002 Start";
719 int32_t userId = 100;
720 string bundleName = "com.ohos.photos";
721 AssetInfoObj obj;
722 std::vector<AssetInfoObj> assetInfoObj;
723 assetInfoObj.push_back(obj);
724 std::vector<bool> assetResultMap;
725 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
726 int ret = proxy_->DownloadFiles(userId, bundleName, assetInfoObj, assetResultMap);
727 EXPECT_EQ(ret, E_BROKEN_IPC);
728 GTEST_LOG_(INFO) << "DownloadFiles002 End";
729 }
730
731 /**
732 * @tc.name: DownloadFiles003
733 * @tc.desc: Verify the DownloadFiles function.
734 * @tc.type: FUNC
735 * @tc.require: I6H5MH
736 */
737 HWTEST_F(CloudSyncServiceProxyTest, DownloadFiles003, TestSize.Level1)
738 {
739 GTEST_LOG_(INFO) << "DownloadFiles002 Start";
740 int32_t userId = 100;
741 string bundleName = "com.ohos.photos";
742 AssetInfoObj obj;
743 std::vector<AssetInfoObj> assetInfoObj;
744 assetInfoObj.push_back(obj);
745 std::vector<bool> assetResultMap;
746 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
747 int ret = proxy_->DownloadFiles(userId, bundleName, assetInfoObj, assetResultMap);
748 EXPECT_EQ(ret, E_OK);
749 GTEST_LOG_(INFO) << "DownloadFiles002 End";
750 }
751
752 /**
753 * @tc.name: DownloadAsset001
754 * @tc.desc: Verify the DownloadAsset function.
755 * @tc.type: FUNC
756 * @tc.require: I6H5MH
757 */
758 HWTEST_F(CloudSyncServiceProxyTest, DownloadAsset001, TestSize.Level1)
759 {
760 GTEST_LOG_(INFO) << "DownloadAsset001 Start";
761 uint64_t taskId = 100;
762 int32_t userId = 100;
763 string bundleName = "com.ohos.photos";
764 string networkId = "";
765 AssetInfoObj assetInfoObj;
766 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
767 int ret = proxy_->DownloadAsset(taskId, userId, bundleName, networkId, assetInfoObj);
768 EXPECT_EQ(ret, E_BROKEN_IPC);
769 GTEST_LOG_(INFO) << "DownloadAsset001 End";
770 }
771
772 /**
773 * @tc.name: DownloadAsset002
774 * @tc.desc: Verify the DownloadAsset function.
775 * @tc.type: FUNC
776 * @tc.require: I6H5MH
777 */
778 HWTEST_F(CloudSyncServiceProxyTest, DownloadAsset002, TestSize.Level1)
779 {
780 GTEST_LOG_(INFO) << "DownloadAsset002 Start";
781 uint64_t taskId = 100;
782 int32_t userId = 100;
783 string bundleName = "com.ohos.photos";
784 string networkId = "";
785 AssetInfoObj assetInfoObj;
786 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
787 int ret = proxy_->DownloadAsset(taskId, userId, bundleName, networkId, assetInfoObj);
788 EXPECT_EQ(ret, E_OK);
789 GTEST_LOG_(INFO) << "DownloadAsset002 End";
790 }
791
792 /**
793 * @tc.name: RegisterDownloadAssetCallback001
794 * @tc.desc: Verify the RegisterDownloadAssetCallback function.
795 * @tc.type: FUNC
796 * @tc.require: I6H5MH
797 */
798 HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadAssetCallback001, TestSize.Level1)
799 {
800 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback Start";
801
802 int ret = proxy_->RegisterDownloadAssetCallback(nullptr);
803 EXPECT_EQ(ret, E_INVAL_ARG);
804 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback End";
805 }
806
807 /**
808 * @tc.name: RegisterDownloadAssetCallback002
809 * @tc.desc: Verify the RegisterDownloadAssetCallback function.
810 * @tc.type: FUNC
811 * @tc.require: I6H5MH
812 */
813 HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadAssetCallback002, TestSize.Level1)
814 {
815 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback Start";
816 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
817
818 int ret = proxy_->RegisterDownloadAssetCallback(remote_);
819 EXPECT_EQ(ret, E_BROKEN_IPC);
820 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback End";
821 }
822
823 /**
824 * @tc.name: RegisterDownloadAssetCallback003
825 * @tc.desc: Verify the RegisterDownloadAssetCallback function.
826 * @tc.type: FUNC
827 * @tc.require: I6H5MH
828 */
829 HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadAssetCallback003, TestSize.Level1)
830 {
831 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback Start";
832 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
833
834 int ret = proxy_->RegisterDownloadAssetCallback(remote_);
835 EXPECT_EQ(ret, E_OK);
836 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback End";
837 }
838
839 /**
840 * @tc.name: DeleteAsset001
841 * @tc.desc: Verify the DeleteAsset function.
842 * @tc.type: FUNC
843 * @tc.require: I6H5MH
844 */
845 HWTEST_F(CloudSyncServiceProxyTest, DeleteAsset001, TestSize.Level1)
846 {
847 GTEST_LOG_(INFO) << "DeleteAsset001 Start";
848 int32_t userId = 100;
849 string uri = "file://media";
850 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
851
852 int ret = proxy_->DeleteAsset(userId, uri);
853 EXPECT_EQ(ret, E_BROKEN_IPC);
854 GTEST_LOG_(INFO) << "DeleteAsset001 End";
855 }
856
857 /**
858 * @tc.name: DeleteAsset002
859 * @tc.desc: Verify the DeleteAsset function.
860 * @tc.type: FUNC
861 * @tc.require: I6H5MH
862 */
863 HWTEST_F(CloudSyncServiceProxyTest, DeleteAsset002, TestSize.Level1)
864 {
865 GTEST_LOG_(INFO) << "DeleteAsset002 Start";
866 int32_t userId = 100;
867 string uri = "file://media";
868 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
869 int ret = proxy_->DeleteAsset(userId, uri);
870 EXPECT_EQ(ret, E_OK);
871 GTEST_LOG_(INFO) << "DeleteAsset002 End";
872 }
873
874 /**
875 * @tc.name: RegisterDownloadFileCallback001
876 * @tc.desc: Verify the RegisterDownloadFileCallback function.
877 * @tc.type: FUNC
878 * @tc.require: issueI7UYAL
879 */
880 HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadFileCallback001, TestSize.Level1)
881 {
882 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback Start";
883 string bundleName = "com.ohos.photos";
884
885 int result = proxy_->RegisterDownloadFileCallback(nullptr);
886 EXPECT_EQ(result, E_INVAL_ARG);
887 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback End";
888 }
889
890 /**
891 * @tc.name: RegisterDownloadFileCallback002
892 * @tc.desc: Verify the RegisterDownloadFileCallback function.
893 * @tc.type: FUNC
894 * @tc.require: I6H5MH
895 */
896 HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadFileCallback002, TestSize.Level1)
897 {
898 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback Start";
899 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
900
901 int result = proxy_->RegisterDownloadFileCallback(remote_);
902 EXPECT_EQ(result, E_BROKEN_IPC);
903 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback End";
904 }
905
906 /**
907 * @tc.name: RegisterDownloadFileCallback003
908 * @tc.desc: Verify the RegisterDownloadFileCallback function.
909 * @tc.type: FUNC
910 * @tc.require: I6H5MH
911 */
912 HWTEST_F(CloudSyncServiceProxyTest, RegisterDownloadFileCallback003, TestSize.Level1)
913 {
914 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback Start";
915 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
916
917 int result = proxy_->RegisterDownloadFileCallback(remote_);
918 EXPECT_EQ(result, E_OK);
919 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback End";
920 }
921
922 /**
923 * @tc.name: UnregisterDownloadFileCallback001
924 * @tc.desc: Verify the UnegisterDownloadFileCallback function.
925 * @tc.type: FUNC
926 * @tc.require: issueI7UYAL
927 */
928 HWTEST_F(CloudSyncServiceProxyTest, UnregisterDownloadFileCallback001, TestSize.Level1)
929 {
930 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback Start";
931 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(-1));
932 int result = proxy_->UnregisterDownloadFileCallback();
933
934 EXPECT_EQ(result, E_BROKEN_IPC);
935 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback End";
936 }
937
938 /**
939 * @tc.name: UnregisterDownloadFileCallback002
940 * @tc.desc: Verify the UnegisterDownloadFileCallback function.
941 * @tc.type: FUNC
942 * @tc.require: issueI7UYAL
943 */
944 HWTEST_F(CloudSyncServiceProxyTest, UnregisterDownloadFileCallback002, TestSize.Level1)
945 {
946 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback Start";
947 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(E_OK));
948 int result = proxy_->UnregisterDownloadFileCallback();
949
950 EXPECT_EQ(result, E_OK);
951 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback End";
952 }
953 } // namespace Test
954 } // namespace FileManagement::CloudSync {
955 } // namespace OHOS