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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "cloud_file_sync_service_interface_code.h"
20 #include "cloud_sync_service_stub.h"
21 #include "dfsu_access_token_helper_mock.h"
22 #include "i_cloud_sync_service.h"
23 #include "service_callback_mock.h"
24
25 namespace OHOS {
26 namespace FileManagement::CloudSync {
27 namespace Test {
28 using namespace testing;
29 using namespace testing::ext;
30 using namespace std;
31
32 class MockService final : public CloudSyncServiceStub {
33 public:
34 MOCK_METHOD2(RegisterCallbackInner,
35 int32_t(const sptr<IRemoteObject> &remoteObject, const std::string &bundleName));
36 MOCK_METHOD2(RegisterFileSyncCallbackInner,
37 int32_t(const sptr<IRemoteObject> &remoteObject, const std::string &bundleName));
38 MOCK_METHOD1(UnRegisterCallbackInner, int32_t(const std::string &bundleName));
39 MOCK_METHOD1(UnRegisterFileSyncCallbackInner, int32_t(const std::string &bundleName));
40 MOCK_METHOD2(StartSyncInner, int32_t(bool forceFlag, const std::string &bundleName));
41 MOCK_METHOD2(StartFileSyncInner, int32_t(bool forceFlag, const std::string &bundleName));
42 MOCK_METHOD2(TriggerSyncInner, int32_t(const std::string &bundleName, const int32_t &userId));
43 MOCK_METHOD2(StopSyncInner, int32_t(const std::string &bundleName, bool forceFlag));
44 MOCK_METHOD2(StopFileSyncInner, int32_t(const std::string &bundleName, bool forceFlag));
45 MOCK_METHOD1(ResetCursor, int32_t(const std::string &bundleName));
46 MOCK_METHOD3(ChangeAppSwitch, int32_t(const std::string &accoutId, const std::string &bundleName, bool status));
47 MOCK_METHOD2(Clean, int32_t(const std::string &accountId, const CleanOptions &cleanOptions));
48 MOCK_METHOD2(NotifyDataChange, int32_t(const std::string &accoutId, const std::string &bundleName));
49 MOCK_METHOD3(NotifyEventChange, int32_t(int32_t userId, const std::string &eventId, const std::string &extraData));
50 MOCK_METHOD2(EnableCloud, int32_t(const std::string &accoutId, const SwitchDataObj &switchData));
51 MOCK_METHOD1(DisableCloud, int32_t(const std::string &accoutId));
52 MOCK_METHOD1(StartDownloadFile, int32_t(const std::string &path));
53 MOCK_METHOD6(StartFileCache, int32_t(const std::vector<std::string> &pathVec, int64_t &downloadId,
54 std::bitset<FIELD_KEY_MAX_SIZE> fieldkey,
55 bool isCallbackValid,
56 const sptr<IRemoteObject> &downloadCallback,
57 int32_t timeout));
58 MOCK_METHOD2(StopDownloadFile, int32_t(const std::string &path, bool needClean));
59 MOCK_METHOD3(StopFileCache, int32_t(int64_t downloadId, bool needClean, int32_t timeout));
60 MOCK_METHOD1(RegisterDownloadFileCallback, int32_t(const sptr<IRemoteObject> &downloadCallback));
61 MOCK_METHOD1(RegisterFileCacheCallback, int32_t(const sptr<IRemoteObject> &downloadCallback));
62 MOCK_METHOD0(UnregisterDownloadFileCallback, int32_t());
63 MOCK_METHOD0(UnregisterFileCacheCallback, int32_t());
64 MOCK_METHOD3(UploadAsset, int32_t(const int32_t userId, const std::string &request, std::string &result));
65 MOCK_METHOD3(DownloadFile,
66 int32_t(const int32_t userId, const std::string &bundleName, AssetInfoObj &assetInfoObj));
67 MOCK_METHOD4(DownloadFiles,
68 int32_t(const int32_t userId,
69 const std::string &bundleName,
70 const std::vector<AssetInfoObj> &assetInfoObj,
71 std::vector<bool> &assetResultMap));
72 MOCK_METHOD5(DownloadAsset,
73 int32_t(const uint64_t taskId,
74 const int32_t userId,
75 const std::string &bundleName,
76 const std::string &networkId,
77 AssetInfoObj &assetInfoObj));
78 MOCK_METHOD1(RegisterDownloadAssetCallback, int32_t(const sptr<IRemoteObject> &remoteObject));
79 MOCK_METHOD2(DeleteAsset, int32_t(const int32_t userId, const std::string &uri));
80 MOCK_METHOD2(GetSyncTimeInner, int32_t(int64_t &syncTime, const std::string &bundleName));
81 MOCK_METHOD1(CleanCacheInner, int32_t(const std::string &uri));
82 MOCK_METHOD0(DownloadThumb, int32_t());
83 MOCK_METHOD2(BatchCleanFile, int32_t(const std::vector<CleanFileInfoObj> &fileInfo,
84 std::vector<std::string> &failCloudId));
85 MOCK_METHOD3(OptimizeStorage, int32_t(const OptimizeSpaceOptions &optimizeOptions, bool isCallbackValid,
86 const sptr<IRemoteObject> &optimizeCallback));
87 MOCK_METHOD2(BatchDentryFileInsert, int32_t(const std::vector<DentryFileInfoObj> &fileInfo,
88 std::vector<std::string> &failCloudId));
89 MOCK_METHOD0(StopOptimizeStorage, int32_t());
90 };
91
92 class CloudSyncServiceStubTest : public testing::Test {
93 public:
94 static void SetUpTestCase(void);
95 static void TearDownTestCase(void);
96 void SetUp();
97 void TearDown();
98 static inline shared_ptr<DfsuAccessTokenMock> dfsuAccessToken_ = nullptr;
99 };
100
SetUpTestCase(void)101 void CloudSyncServiceStubTest::SetUpTestCase(void)
102 {
103 dfsuAccessToken_ = make_shared<DfsuAccessTokenMock>();
104 DfsuAccessTokenMock::dfsuAccessToken = dfsuAccessToken_;
105 std::cout << "SetUpTestCase" << std::endl;
106 }
107
TearDownTestCase(void)108 void CloudSyncServiceStubTest::TearDownTestCase(void)
109 {
110 DfsuAccessTokenMock::dfsuAccessToken = nullptr;
111 dfsuAccessToken_ = nullptr;
112 std::cout << "TearDownTestCase" << std::endl;
113 }
114
SetUp(void)115 void CloudSyncServiceStubTest::SetUp(void)
116 {
117 std::cout << "SetUp" << std::endl;
118 }
119
TearDown(void)120 void CloudSyncServiceStubTest::TearDown(void)
121 {
122 std::cout << "TearDown" << std::endl;
123 }
124
125 /**
126 * @tc.name: HandleOptimizeStorageTest001
127 * @tc.desc: Verify the HandleOptimizeStorage function.
128 * @tc.type: FUNC
129 * @tc.require: I6H5MH
130 */
131 HWTEST_F(CloudSyncServiceStubTest, HandleOptimizeStorageTest001, TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "HandleOptimizeStorage Start";
134 try {
135 MockService service;
136 MessageParcel data;
137 MessageParcel reply;
138
139 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
140 int32_t res = service.HandleOptimizeStorage(data, reply);
141 EXPECT_EQ(res, E_PERMISSION_DENIED);
142
143 } catch (...) {
144 EXPECT_TRUE(false);
145 GTEST_LOG_(INFO) << " HandleOptimizeStorage ERROR";
146 }
147 GTEST_LOG_(INFO) << "HandleOptimizeStorage End";
148 }
149
150 /**
151 * @tc.name: HandleOptimizeStorageTest002
152 * @tc.desc: Verify the HandleOptimizeStorage function.
153 * @tc.type: FUNC
154 * @tc.require: I6H5MH
155 */
156 HWTEST_F(CloudSyncServiceStubTest, HandleOptimizeStorageTest002, TestSize.Level1)
157 {
158 GTEST_LOG_(INFO) << "HandleOptimizeStorage Start";
159 try {
160 MockService service;
161 MessageParcel data;
162 MessageParcel reply;
163
164 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
165 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
166 int32_t res = service.HandleOptimizeStorage(data, reply);
167 EXPECT_EQ(res, E_PERMISSION_SYSTEM);
168
169 } catch (...) {
170 EXPECT_TRUE(false);
171 GTEST_LOG_(INFO) << " HandleOptimizeStorage ERROR";
172 }
173 GTEST_LOG_(INFO) << "HandleOptimizeStorage End";
174 }
175
176 /**
177 * @tc.name: HandleOptimizeStorageTest003
178 * @tc.desc: Verify the HandleOptimizeStorage function.
179 * @tc.type: FUNC
180 * @tc.require: I6H5MH
181 */
182 HWTEST_F(CloudSyncServiceStubTest, HandleOptimizeStorageTest003, TestSize.Level1)
183 {
184 GTEST_LOG_(INFO) << "HandleOptimizeStorage Start";
185 try {
186 MockService service;
187 MessageParcel data;
188 MessageParcel reply;
189
190 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
191 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
192 int32_t res = service.HandleOptimizeStorage(data, reply);
193 EXPECT_EQ(res, E_OK);
194
195 } catch (...) {
196 EXPECT_TRUE(false);
197 GTEST_LOG_(INFO) << " HandleOptimizeStorage ERROR";
198 }
199 GTEST_LOG_(INFO) << "HandleOptimizeStorage End";
200 }
201
202 /**
203 * @tc.name: HandleEnableCloudTest003
204 * @tc.desc: Verify the HandleEnableCloud function.
205 * @tc.type: FUNC
206 * @tc.require: I6H5MH
207 */
208 HWTEST_F(CloudSyncServiceStubTest, HandleEnableCloudTest003, TestSize.Level1)
209 {
210 GTEST_LOG_(INFO) << "HandleEnableCloud Start";
211 try {
212 MockService service;
213 MessageParcel data;
214 MessageParcel reply;
215
216 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
217 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
218 int32_t res = service.HandleEnableCloud(data, reply);
219 EXPECT_EQ(res, E_INVAL_ARG);
220
221 } catch (...) {
222 EXPECT_TRUE(false);
223 GTEST_LOG_(INFO) << " HandleEnableCloud ERROR";
224 }
225 GTEST_LOG_(INFO) << "HandleEnableCloud End";
226 }
227
228 /**
229 * @tc.name: HandleStartFileCacheTest003
230 * @tc.desc: Verify the HandleStartFileCache function.
231 * @tc.type: FUNC
232 * @tc.require: I6H5MH
233 */
234 HWTEST_F(CloudSyncServiceStubTest, HandleStartFileCacheTest003, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "HandleStartFileCache Start";
237 try {
238 MockService service;
239 MessageParcel data;
240 MessageParcel reply;
241 data.writable_ = true;
242
243 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
244 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
245 EXPECT_CALL(*dfsuAccessToken_, CheckUriPermission(_)).WillOnce(Return(false));
246 int32_t res = service.HandleStartFileCache(data, reply);
247 EXPECT_EQ(res, E_OK);
248
249 } catch (...) {
250 EXPECT_TRUE(false);
251 GTEST_LOG_(INFO) << " HandleStartFileCache ERROR";
252 }
253 GTEST_LOG_(INFO) << "HandleStartFileCache End";
254 }
255
256 /**
257 * @tc.name: HandleDownloadThumbTest001
258 * @tc.desc: Verify the HandleDownloadThumb function.
259 * @tc.type: FUNC
260 * @tc.require: I6H5MH
261 */
262 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadThumbTest001, TestSize.Level1)
263 {
264 GTEST_LOG_(INFO) << "HandleDownloadThumb Start";
265 try {
266 MockService service;
267 MessageParcel data;
268 MessageParcel reply;
269
270 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
271 int32_t res = service.HandleDownloadThumb(data, reply);
272 EXPECT_EQ(res, E_PERMISSION_SYSTEM);
273
274 } catch (...) {
275 EXPECT_TRUE(false);
276 GTEST_LOG_(INFO) << " HandleDownloadThumb ERROR";
277 }
278 GTEST_LOG_(INFO) << "HandleDownloadThumb End";
279 }
280
281 /**
282 * @tc.name: HandleDownloadThumbTest002
283 * @tc.desc: Verify the HandleDownloadThumb function.
284 * @tc.type: FUNC
285 * @tc.require: I6H5MH
286 */
287 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadThumbTest002, TestSize.Level1)
288 {
289 GTEST_LOG_(INFO) << "HandleDownloadThumb Start";
290 try {
291 MockService service;
292 MessageParcel data;
293 MessageParcel reply;
294
295 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
296 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
297 int32_t res = service.HandleDownloadThumb(data, reply);
298 EXPECT_EQ(res, E_PERMISSION_DENIED);
299
300 } catch (...) {
301 EXPECT_TRUE(false);
302 GTEST_LOG_(INFO) << " HandleDownloadThumb ERROR";
303 }
304 GTEST_LOG_(INFO) << "HandleDownloadThumb End";
305 }
306
307 /**
308 * @tc.name: HandleDownloadThumbTest003
309 * @tc.desc: Verify the HandleDownloadThumb function.
310 * @tc.type: FUNC
311 * @tc.require: I6H5MH
312 */
313 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadThumbTest003, TestSize.Level1)
314 {
315 GTEST_LOG_(INFO) << "HandleDownloadThumb Start";
316 try {
317 MockService service;
318 MessageParcel data;
319 MessageParcel reply;
320
321 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
322 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
323 int32_t res = service.HandleDownloadThumb(data, reply);
324 EXPECT_EQ(res, E_OK);
325
326 } catch (...) {
327 EXPECT_TRUE(false);
328 GTEST_LOG_(INFO) << " HandleDownloadThumb ERROR";
329 }
330 GTEST_LOG_(INFO) << "HandleDownloadThumb End";
331 }
332
333 /**
334 * @tc.name: HandleUnRegisterCallbackInnerTest
335 * @tc.desc: Verify the HandleUnRegisterCallbackInner function.
336 * @tc.type: FUNC
337 * @tc.require: I6H5MH
338 */
339 HWTEST_F(CloudSyncServiceStubTest, HandleUnRegisterCallbackInnerTest, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "HandleUnRegisterCallbackInner Start";
342 try {
343 string bundleName = "";
344 MockService service;
345 EXPECT_CALL(service, UnRegisterCallbackInner(bundleName)).WillOnce(Return(E_OK));
346 MessageParcel data;
347 MessageParcel reply;
348 MessageOption option;
349 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
350 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
351 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
352
353 sptr<CloudSyncCallbackMock> remote = sptr(new CloudSyncCallbackMock());
354 EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr()));
355
356 EXPECT_TRUE(data.WriteString(bundleName));
357
358 EXPECT_EQ(E_OK, service.OnRemoteRequest(
359 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_CALLBACK),
360 data, reply, option));
361 remote = nullptr;
362 } catch (...) {
363 EXPECT_TRUE(false);
364 GTEST_LOG_(INFO) << " HandleUnRegisterCallbackInner ERROR";
365 }
366 GTEST_LOG_(INFO) << "HandleUnRegisterCallbackInner End";
367 }
368
369 /**
370 * @tc.name: HandleRegisterCallbackInnerTest
371 * @tc.desc: Verify the HandleRegisterCallbackInner function.
372 * @tc.type: FUNC
373 * @tc.require: I6H5MH
374 */
375 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterCallbackInnerTest, TestSize.Level1)
376 {
377 GTEST_LOG_(INFO) << "HandleRegisterCallbackInner Start";
378 try {
379 string bundleName = "";
380 MockService service;
381 EXPECT_CALL(service, RegisterCallbackInner(_, bundleName)).WillOnce(Return(E_OK));
382 MessageParcel data;
383 MessageParcel reply;
384 MessageOption option;
385 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
386 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
387 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
388
389 sptr<CloudSyncCallbackMock> remote = sptr(new CloudSyncCallbackMock());
390 EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr()));
391
392 EXPECT_TRUE(data.WriteString(bundleName));
393
394 EXPECT_EQ(E_OK, service.OnRemoteRequest(
395 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_CALLBACK),
396 data, reply, option));
397 remote = nullptr;
398 } catch (...) {
399 EXPECT_TRUE(false);
400 GTEST_LOG_(INFO) << " HandleRegisterCallbackInner ERROR";
401 }
402 GTEST_LOG_(INFO) << "HandleRegisterCallbackInner End";
403 }
404
405 /**
406 * @tc.name: HandleStartSyncInnerTest
407 * @tc.desc: Verify the HandleStartSyncInner function.
408 * @tc.type: FUNC
409 * @tc.require: I6H5MH
410 */
411 HWTEST_F(CloudSyncServiceStubTest, HandleStartSyncInnerTest, TestSize.Level1)
412 {
413 GTEST_LOG_(INFO) << "HandleStartSyncInner Start";
414 try {
415 string bundleName = "";
416 MockService service;
417 EXPECT_CALL(service, StartSyncInner(_, bundleName)).WillOnce(Return(E_OK));
418 MessageParcel data;
419 MessageParcel reply;
420 MessageOption option;
421 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
422 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
423 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
424
425 bool forceFlag = true;
426 EXPECT_TRUE(data.WriteBool(forceFlag));
427
428 EXPECT_TRUE(data.WriteString(bundleName));
429
430 EXPECT_EQ(E_OK, service.OnRemoteRequest(
431 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_SYNC), data,
432 reply, option));
433 } catch (...) {
434 EXPECT_TRUE(false);
435 GTEST_LOG_(INFO) << " HandleStartSyncInner ERROR";
436 }
437 GTEST_LOG_(INFO) << "HandleStartSyncInner End";
438 }
439
440 /**
441 * @tc.name: HandleTriggerSyncInnerTest
442 * @tc.desc: Verify the HandleStartSyncInner function.
443 * @tc.type: FUNC
444 * @tc.require: I6H5MH
445 */
446 HWTEST_F(CloudSyncServiceStubTest, HandleTriggerSyncInnerTest, TestSize.Level1)
447 {
448 GTEST_LOG_(INFO) << "HandleTriggerSyncInner Start";
449 try {
450 MockService service;
451 EXPECT_CALL(service, TriggerSyncInner(_, _)).WillOnce(Return(E_OK));
452 MessageParcel data;
453 MessageParcel reply;
454 MessageOption option;
455 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
456 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
457 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
458
459 EXPECT_EQ(E_OK, service.OnRemoteRequest(
460 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_TRIGGER_SYNC), data,
461 reply, option));
462 } catch (...) {
463 EXPECT_TRUE(false);
464 GTEST_LOG_(INFO) << " HandleTriggerSyncInner ERROR";
465 }
466 GTEST_LOG_(INFO) << "HandleTriggerSyncInner End";
467 }
468
469 /**
470 * @tc.name: HandleStopSyncInnerTest
471 * @tc.desc: Verify the HandleStopSyncInner function.
472 * @tc.type: FUNC
473 * @tc.require: I6H5MH
474 */
475 HWTEST_F(CloudSyncServiceStubTest, HandleStopSyncInnerTest, TestSize.Level1)
476 {
477 GTEST_LOG_(INFO) << "HandleStopSyncInner Start";
478 try {
479 string bundleName = "";
480 bool forceFlag = false;
481 MockService service;
482 EXPECT_CALL(service, StopSyncInner(bundleName, forceFlag)).WillOnce(Return(E_OK));
483 MessageParcel data;
484 MessageParcel reply;
485 MessageOption option;
486 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
487 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
488 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
489
490 EXPECT_TRUE(data.WriteString(bundleName));
491
492 EXPECT_TRUE(data.WriteBool(forceFlag));
493
494 EXPECT_EQ(E_OK, service.OnRemoteRequest(
495 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_SYNC), data,
496 reply, option));
497 } catch (...) {
498 EXPECT_TRUE(false);
499 GTEST_LOG_(INFO) << " HandleStopSyncInner ERROR";
500 }
501 GTEST_LOG_(INFO) << "HandleStopSyncInner End";
502 }
503
504 /**
505 * @tc.name: HandleChangeAppSwitchTest
506 * @tc.desc: Verify the HandleChangeAppSwitch function.
507 * @tc.type: FUNC
508 * @tc.require: I6H5MH
509 */
510 HWTEST_F(CloudSyncServiceStubTest, HandleChangeAppSwitchTest, TestSize.Level1)
511 {
512 GTEST_LOG_(INFO) << "HandleChangeAppSwitch Start";
513 try {
514 MockService service;
515 EXPECT_CALL(service, ChangeAppSwitch(_, _, _)).WillOnce(Return(E_OK));
516 MessageParcel data;
517 MessageParcel reply;
518 MessageOption option;
519 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
520 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
521 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
522
523 EXPECT_EQ(E_OK, service.OnRemoteRequest(
524 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CHANGE_APP_SWITCH),
525 data, reply, option));
526 } catch (...) {
527 EXPECT_TRUE(false);
528 GTEST_LOG_(INFO) << " HandleChangeAppSwitch ERROR";
529 }
530 GTEST_LOG_(INFO) << "HandleChangeAppSwitch End";
531 }
532
533 /**
534 * @tc.name: HandleCleanTest
535 * @tc.desc: Verify the HandleClean function.
536 * @tc.type: FUNC
537 * @tc.require: I6H5MH
538 */
539 HWTEST_F(CloudSyncServiceStubTest, HandleCleandTest, TestSize.Level1)
540 {
541 GTEST_LOG_(INFO) << "HandleClean Start";
542 try {
543 MockService service;
544 MessageParcel data;
545 MessageParcel reply;
546 MessageOption option;
547 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
548 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
549 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
550
551 EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
552 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN), data,
553 reply, option));
554 } catch (...) {
555 EXPECT_TRUE(false);
556 GTEST_LOG_(INFO) << " HandleClean ERROR";
557 }
558 GTEST_LOG_(INFO) << "HandleClean End";
559 }
560
561 /**
562 * @tc.name: HandleNotifyDataChangeTest
563 * @tc.desc: Verify the HandleNotifyDataChange function.
564 * @tc.type: FUNC
565 * @tc.require: I6H5MH
566 */
567 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyDataChangeTest, TestSize.Level1)
568 {
569 GTEST_LOG_(INFO) << "HandleNotifyDataChange Start";
570 try {
571 MockService service;
572 EXPECT_CALL(service, NotifyDataChange(_, _)).WillOnce(Return(E_OK));
573 MessageParcel data;
574 MessageParcel reply;
575 MessageOption option;
576 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
577 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
578 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
579
580 EXPECT_EQ(E_OK, service.OnRemoteRequest(
581 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_DATA_CHANGE),
582 data, reply, option));
583 } catch (...) {
584 EXPECT_TRUE(false);
585 GTEST_LOG_(INFO) << " HandleNotifyDataChange ERROR";
586 }
587 GTEST_LOG_(INFO) << "HandleNotifyDataChange End";
588 }
589
590 /**
591 * @tc.name: HandleNotifyEventChangeTest
592 * @tc.desc: Verify the HandleNotifyEventChange function.
593 * @tc.type: FUNC
594 * @tc.require: I6H5MH
595 */
596 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyEventChangeTest, TestSize.Level1)
597 {
598 GTEST_LOG_(INFO) << "HandleNotifyEventChange Start";
599 try {
600 MockService service;
601 EXPECT_CALL(service, NotifyEventChange(_, _, _)).WillOnce(Return(E_OK));
602 MessageParcel data;
603 MessageParcel reply;
604 MessageOption option;
605 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
606 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
607 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
608
609 EXPECT_EQ(E_OK, service.OnRemoteRequest(
610 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_EVENT_CHANGE),
611 data, reply, option));
612 } catch (...) {
613 EXPECT_TRUE(false);
614 GTEST_LOG_(INFO) << " HandleNotifyEventChange ERROR";
615 }
616 GTEST_LOG_(INFO) << "HandleNotifyEventChange End";
617 }
618
619 /**
620 * @tc.name: HandleDisableCloudTest
621 * @tc.desc: Verify the HandleDisableCloud function.
622 * @tc.type: FUNC
623 * @tc.require: I6H5MH
624 */
625 HWTEST_F(CloudSyncServiceStubTest, HandleDisableCloudTest, TestSize.Level1)
626 {
627 GTEST_LOG_(INFO) << "HandleStopSyncInner Start";
628 try {
629 MockService service;
630 EXPECT_CALL(service, DisableCloud(_)).WillOnce(Return(E_OK));
631 MessageParcel data;
632 MessageParcel reply;
633 MessageOption option;
634 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
635 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
636 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
637
638 EXPECT_EQ(E_OK, service.OnRemoteRequest(
639 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DISABLE_CLOUD), data,
640 reply, option));
641 } catch (...) {
642 EXPECT_TRUE(false);
643 GTEST_LOG_(INFO) << " HandleDisableCloud ERROR";
644 }
645 GTEST_LOG_(INFO) << "HandleDisableCloud End";
646 }
647
648 /**
649 * @tc.name: HandleEnableCloudTest
650 * @tc.desc: Verify the HandleEnableCloud function.
651 * @tc.type: FUNC
652 * @tc.require: I6H5MH
653 */
654 HWTEST_F(CloudSyncServiceStubTest, HandleEnableCloudTest, TestSize.Level1)
655 {
656 GTEST_LOG_(INFO) << "HandleEnableCloudFile Start";
657 try {
658 MockService service;
659 MessageParcel data;
660 MessageParcel reply;
661 MessageOption option;
662 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
663 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
664 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
665
666 EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
667 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_ENABLE_CLOUD), data,
668 reply, option));
669 } catch (...) {
670 EXPECT_TRUE(false);
671 GTEST_LOG_(INFO) << " HandleEnableCloud ERROR";
672 }
673 GTEST_LOG_(INFO) << "HandleEnableCloud End";
674 }
675
676 /**
677 * @tc.name: HandleStartDownloadFileTest
678 * @tc.desc: Verify the HandleStartDownloadFile function.
679 * @tc.type: FUNC
680 * @tc.require: I6H5MH
681 */
682 HWTEST_F(CloudSyncServiceStubTest, HandleStartDownloadFileTest, TestSize.Level1)
683 {
684 GTEST_LOG_(INFO) << "HandleStartDownloadFile Start";
685 try {
686 MockService service;
687 EXPECT_CALL(service, StartDownloadFile(_)).WillOnce(Return(E_OK));
688 MessageParcel data;
689 MessageParcel reply;
690 MessageOption option;
691 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
692 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
693 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
694
695 EXPECT_EQ(E_OK, service.OnRemoteRequest(
696 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE),
697 data, reply, option));
698 } catch (...) {
699 EXPECT_TRUE(false);
700 GTEST_LOG_(INFO) << " HandleStartDownloadFile ERROR";
701 }
702 GTEST_LOG_(INFO) << "HandleStartDownloadFile End";
703 }
704
705 /**
706 * @tc.name: HandleStopDownloadFileTest
707 * @tc.desc: Verify the HandleStopDownloadFile function.
708 * @tc.type: FUNC
709 * @tc.require: I6H5MH
710 */
711 HWTEST_F(CloudSyncServiceStubTest, HandleStopDownloadFileTest, TestSize.Level1)
712 {
713 GTEST_LOG_(INFO) << "HandleStopDownloadFile Start";
714 try {
715 MockService service;
716 EXPECT_CALL(service, StopDownloadFile(_, _)).WillOnce(Return(E_OK));
717 MessageParcel data;
718 MessageParcel reply;
719 MessageOption option;
720 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
721 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
722 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
723
724 EXPECT_EQ(E_OK, service.OnRemoteRequest(
725 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE),
726 data, reply, option));
727 } catch (...) {
728 EXPECT_TRUE(false);
729 GTEST_LOG_(INFO) << " HandleStopDownloadFile ERROR";
730 }
731 GTEST_LOG_(INFO) << "HandleStopDownloadFile End";
732 }
733
734 /**
735 * @tc.name: HandleRegisterDownloadFileCallbackTest
736 * @tc.desc: Verify the HandleRegisterDownloadFileCallback function.
737 * @tc.type: FUNC
738 * @tc.require: I6H5MH
739 */
740 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadFileCallbackTest, TestSize.Level1)
741 {
742 GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback Start";
743 try {
744 MockService service;
745 EXPECT_CALL(service, RegisterDownloadFileCallback(_)).WillOnce(Return(E_OK));
746 MessageParcel data;
747 MessageParcel reply;
748 MessageOption option;
749 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
750 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
751 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
752
753 EXPECT_EQ(E_OK, service.OnRemoteRequest(
754 static_cast<uint32_t>(
755 CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK),
756 data, reply, option));
757 } catch (...) {
758 EXPECT_TRUE(false);
759 GTEST_LOG_(INFO) << " HandleRegisterDownloadFileCallback ERROR";
760 }
761 GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback End";
762 }
763
764 /**
765 * @tc.name: HandleUnregisterDownloadFileCallbackTest
766 * @tc.desc: Verify the HandleUnregisterDownloadFileCallback function.
767 * @tc.type: FUNC
768 * @tc.require: I6H5MH
769 */
770 HWTEST_F(CloudSyncServiceStubTest, HandleUnregisterDownloadFileCallbackTest, TestSize.Level1)
771 {
772 GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback Start";
773 try {
774 MockService service;
775 EXPECT_CALL(service, UnregisterDownloadFileCallback()).WillOnce(Return(E_OK));
776 MessageParcel data;
777 MessageParcel reply;
778 MessageOption option;
779 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
780 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
781 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
782
783 EXPECT_EQ(E_OK, service.OnRemoteRequest(
784 static_cast<uint32_t>(
785 CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK),
786 data, reply, option));
787 } catch (...) {
788 EXPECT_TRUE(false);
789 GTEST_LOG_(INFO) << " HandleUnregisterDownloadFileCallback ERROR";
790 }
791 GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback End";
792 }
793
794 /**
795 * @tc.name: HandleUploadAssetTest
796 * @tc.desc: Verify the HandleUploadAsset function.
797 * @tc.type: FUNC
798 * @tc.require: I6H5MH
799 */
800 HWTEST_F(CloudSyncServiceStubTest, HandleUploadAssetTest, TestSize.Level1)
801 {
802 GTEST_LOG_(INFO) << "HandleUploadAsset Start";
803 try {
804 MockService service;
805 EXPECT_CALL(service, UploadAsset(_, _, _)).WillOnce(Return(E_OK));
806 MessageParcel data;
807 MessageParcel reply;
808 MessageOption option;
809 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
810 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
811 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
812
813 EXPECT_EQ(E_OK, service.OnRemoteRequest(
814 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UPLOAD_ASSET), data,
815 reply, option));
816 } catch (...) {
817 EXPECT_TRUE(false);
818 GTEST_LOG_(INFO) << " HandleUploadAsset ERROR";
819 }
820 GTEST_LOG_(INFO) << "HandleUploadAsset End";
821 }
822
823 /**
824 * @tc.name: HandleDownloadFileTest
825 * @tc.desc: Verify the HandleDownloadFile function.
826 * @tc.type: FUNC
827 * @tc.require: I6H5MH
828 */
829 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFileTest, TestSize.Level1)
830 {
831 GTEST_LOG_(INFO) << "HandleDownloadFile Start";
832 try {
833 MockService service;
834 MessageParcel data;
835 MessageParcel reply;
836 MessageOption option;
837 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
838 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
839 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
840
841 EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
842 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILE), data,
843 reply, option));
844 } catch (...) {
845 EXPECT_TRUE(false);
846 GTEST_LOG_(INFO) << " HandleDownloadFile ERROR";
847 }
848 GTEST_LOG_(INFO) << "HandleDownloadFile End";
849 }
850
851 /**
852 * @tc.name: HandleDownloadAssetTest
853 * @tc.desc: Verify the HandleDownloadAsset function.
854 * @tc.type: FUNC
855 * @tc.require: I6H5MH
856 */
857 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadAssetTest, TestSize.Level1)
858 {
859 GTEST_LOG_(INFO) << "HandleDownloadAsset Start";
860 try {
861 MockService service;
862 MessageParcel data;
863 MessageParcel reply;
864 MessageOption option;
865 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
866 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
867 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
868
869 EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
870 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_ASSET), data,
871 reply, option));
872 } catch (...) {
873 EXPECT_TRUE(false);
874 GTEST_LOG_(INFO) << " HandleDownloadAsset ERROR";
875 }
876 GTEST_LOG_(INFO) << "HandleDownloadAsset End";
877 }
878
879 /**
880 * @tc.name: HandleRegisterDownloadAssetCallbackTest
881 * @tc.desc: Verify the HandleRegisterDownloadAssetCallback function.
882 * @tc.type: FUNC
883 * @tc.require: I6H5MH
884 */
885 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadAssetCallbackTest, TestSize.Level1)
886 {
887 GTEST_LOG_(INFO) << "HandleRegisterDownloadAssetCallback Start";
888 try {
889 MockService service;
890 MessageParcel data;
891 MessageParcel reply;
892 MessageOption option;
893 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
894 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
895 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
896
897 EXPECT_EQ(E_OK, service.OnRemoteRequest(
898 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK),
899 data, reply, option));
900 } catch (...) {
901 EXPECT_TRUE(false);
902 GTEST_LOG_(INFO) << " HandleRegisterDownloadAssetCallback ERROR";
903 }
904 GTEST_LOG_(INFO) << "HandleRegisterDownloadAssetCallback End";
905 }
906
907 /**
908 * @tc.name: HandleDeleteAssetTest
909 * @tc.desc: Verify the HandleDeleteAsset function.
910 * @tc.type: FUNC
911 * @tc.require: I6H5MH
912 */
913 HWTEST_F(CloudSyncServiceStubTest, HandleDeleteAssetTest, TestSize.Level1)
914 {
915 GTEST_LOG_(INFO) << "HandleDeleteAsset Start";
916 try {
917 MockService service;
918 EXPECT_CALL(service, DeleteAsset(_, _)).WillOnce(Return(E_OK));
919 MessageParcel data;
920 MessageParcel reply;
921 MessageOption option;
922 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
923 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
924 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
925
926 EXPECT_EQ(E_OK, service.OnRemoteRequest(
927 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DELETE_ASSET),
928 data, reply, option));
929 } catch (...) {
930 EXPECT_TRUE(false);
931 GTEST_LOG_(INFO) << "HandleDeleteAsset ERROR";
932 }
933 GTEST_LOG_(INFO) << "HandleDeleteAsset End";
934 }
935
936 /**
937 * @tc.name: HandleGetSyncTimeTest
938 * @tc.desc: Verify the HandleGetSyncTime function.
939 * @tc.type: FUNC
940 * @tc.require: I6H5MH
941 */
942 HWTEST_F(CloudSyncServiceStubTest, HandleGetSyncTimeTest, TestSize.Level1)
943 {
944 GTEST_LOG_(INFO) << "HandleGetSyncTime Start";
945 try {
946 string bundleName = "";
947 MockService service;
948 EXPECT_CALL(service, GetSyncTimeInner(_, bundleName)).WillOnce(Return(E_OK));
949 MessageParcel data;
950 MessageParcel reply;
951 MessageOption option;
952 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
953 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
954 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
955
956 EXPECT_TRUE(data.WriteString(bundleName));
957
958 EXPECT_EQ(E_OK, service.OnRemoteRequest(
959 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_GET_SYNC_TIME),
960 data, reply, option));
961 } catch (...) {
962 EXPECT_TRUE(false);
963 GTEST_LOG_(INFO) << "HandleGetSyncTime ERROR";
964 }
965 GTEST_LOG_(INFO) << "HandleGetSyncTime End";
966 }
967
968 /**
969 * @tc.name: HandleCleanCacheTest
970 * @tc.desc: Verify the HandleCleanCache function.
971 * @tc.type: FUNC
972 * @tc.require: I6H5MH
973 */
974 HWTEST_F(CloudSyncServiceStubTest, HandleCleanCacheTest, TestSize.Level1)
975 {
976 GTEST_LOG_(INFO) << "HandleCleanCache Start";
977 try {
978 MockService service;
979 EXPECT_CALL(service, CleanCacheInner(_)).WillOnce(Return(E_OK));
980 MessageParcel data;
981 MessageParcel reply;
982 MessageOption option;
983 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
984 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
985 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
986
987 EXPECT_EQ(E_OK, service.OnRemoteRequest(
988 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN_CACHE),
989 data, reply, option));
990 } catch (...) {
991 EXPECT_TRUE(false);
992 GTEST_LOG_(INFO) << "HandleCleanCache ERROR";
993 }
994 GTEST_LOG_(INFO) << "HandleCleanCache End";
995 }
996
997 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadAssetTest001, TestSize.Level1)
998 {
999 MockService service;
1000 MessageParcel data;
1001 MessageParcel reply;
1002 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1003 int32_t ret = service.HandleDownloadAsset(data, reply);
1004
1005 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1006 }
1007
1008 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadAssetTest002, TestSize.Level1)
1009 {
1010 MockService service;
1011 MessageParcel data;
1012 MessageParcel reply;
1013 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1014 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1015 int32_t ret = service.HandleDownloadAsset(data, reply);
1016
1017 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1018 }
1019
1020 HWTEST_F(CloudSyncServiceStubTest, HandleUnRegisterCallbackInnerTest001, TestSize.Level1)
1021 {
1022 MockService service;
1023 MessageParcel data;
1024 MessageParcel reply;
1025 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1026 int32_t ret = service.HandleUnRegisterCallbackInner(data, reply);
1027
1028 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1029 }
1030
1031 HWTEST_F(CloudSyncServiceStubTest, HandleUnRegisterCallbackInnerTest002, TestSize.Level1)
1032 {
1033 MockService service;
1034 MessageParcel data;
1035 MessageParcel reply;
1036 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1037 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1038 int32_t ret = service.HandleUnRegisterCallbackInner(data, reply);
1039
1040 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1041 }
1042
1043 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterCallbackInnerTest001, TestSize.Level1)
1044 {
1045 MockService service;
1046 MessageParcel data;
1047 MessageParcel reply;
1048 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1049 int32_t ret = service.HandleRegisterCallbackInner(data, reply);
1050
1051 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1052 }
1053
1054 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterCallbackInnerTest002, TestSize.Level1)
1055 {
1056 MockService service;
1057 MessageParcel data;
1058 MessageParcel reply;
1059 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1060 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1061 int32_t ret = service.HandleRegisterCallbackInner(data, reply);
1062
1063 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1064 }
1065
1066 HWTEST_F(CloudSyncServiceStubTest, HandleStartSyncInnerTest001, TestSize.Level1)
1067 {
1068 MockService service;
1069 MessageParcel data;
1070 MessageParcel reply;
1071 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1072 int32_t ret = service.HandleStartSyncInner(data, reply);
1073
1074 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1075 }
1076
1077 HWTEST_F(CloudSyncServiceStubTest, HandleStartSyncInnerTest002, TestSize.Level1)
1078 {
1079 MockService service;
1080 MessageParcel data;
1081 MessageParcel reply;
1082 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1083 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1084 int32_t ret = service.HandleStartSyncInner(data, reply);
1085
1086 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1087 }
1088
1089 HWTEST_F(CloudSyncServiceStubTest, HandleTriggerSyncInnerTest001, TestSize.Level1)
1090 {
1091 MockService service;
1092 MessageParcel data;
1093 MessageParcel reply;
1094 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1095 int32_t ret = service.HandleTriggerSyncInner(data, reply);
1096
1097 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1098 }
1099
1100 HWTEST_F(CloudSyncServiceStubTest, HandleTriggerSyncInnerTest002, TestSize.Level1)
1101 {
1102 MockService service;
1103 MessageParcel data;
1104 MessageParcel reply;
1105 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1106 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1107 int32_t ret = service.HandleTriggerSyncInner(data, reply);
1108
1109 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1110 }
1111
1112 HWTEST_F(CloudSyncServiceStubTest, HandleStopSyncInnerTest001, TestSize.Level1)
1113 {
1114 MockService service;
1115 MessageParcel data;
1116 MessageParcel reply;
1117 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1118 int32_t ret = service.HandleStopSyncInner(data, reply);
1119
1120 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1121 }
1122
1123 HWTEST_F(CloudSyncServiceStubTest, HandleStopSyncInnerTest002, TestSize.Level1)
1124 {
1125 MockService service;
1126 MessageParcel data;
1127 MessageParcel reply;
1128 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1129 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1130 int32_t ret = service.HandleStopSyncInner(data, reply);
1131
1132 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1133 }
1134
1135 HWTEST_F(CloudSyncServiceStubTest, HandleResetCursorTest001, TestSize.Level1)
1136 {
1137 MockService service;
1138 MessageParcel data;
1139 MessageParcel reply;
1140 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1141 int32_t ret = service.HandleResetCursor(data, reply);
1142
1143 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1144 }
1145
1146 HWTEST_F(CloudSyncServiceStubTest, HandleResetCursorTest002, TestSize.Level1)
1147 {
1148 MockService service;
1149 MessageParcel data;
1150 MessageParcel reply;
1151 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1152 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1153 int32_t ret = service.HandleResetCursor(data, reply);
1154
1155 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1156 }
1157
1158 HWTEST_F(CloudSyncServiceStubTest, HandleResetCursorTest003, TestSize.Level1)
1159 {
1160 MockService service;
1161 MessageParcel data;
1162 MessageParcel reply;
1163 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1164 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1165 int32_t ret = service.HandleResetCursor(data, reply);
1166
1167 EXPECT_EQ(ret, E_OK);
1168 }
1169
1170 HWTEST_F(CloudSyncServiceStubTest, HandleChangeAppSwitchTest001, TestSize.Level1)
1171 {
1172 MockService service;
1173 MessageParcel data;
1174 MessageParcel reply;
1175 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1176 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1177 int32_t ret = service.HandleChangeAppSwitch(data, reply);
1178
1179 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1180 }
1181
1182 HWTEST_F(CloudSyncServiceStubTest, HandleChangeAppSwitchTest002, TestSize.Level1)
1183 {
1184 MockService service;
1185 MessageParcel data;
1186 MessageParcel reply;
1187 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1188 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1189 int32_t ret = service.HandleChangeAppSwitch(data, reply);
1190
1191 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1192 }
1193
1194 HWTEST_F(CloudSyncServiceStubTest, HandleCleanTest001, TestSize.Level1)
1195 {
1196 MockService service;
1197 MessageParcel data;
1198 MessageParcel reply;
1199 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1200 int32_t ret = service.HandleClean(data, reply);
1201
1202 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1203 }
1204
1205 HWTEST_F(CloudSyncServiceStubTest, HandleCleanTest002, TestSize.Level1)
1206 {
1207 MockService service;
1208 MessageParcel data;
1209 MessageParcel reply;
1210 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1211 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1212 int32_t ret = service.HandleClean(data, reply);
1213
1214 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1215 }
1216
1217 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyDataChangeTest001, TestSize.Level1)
1218 {
1219 MockService service;
1220 MessageParcel data;
1221 MessageParcel reply;
1222 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1223 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1224 int32_t ret = service.HandleNotifyDataChange(data, reply);
1225
1226 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1227 }
1228
1229 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyDataChangeTest002, TestSize.Level1)
1230 {
1231 MockService service;
1232 MessageParcel data;
1233 MessageParcel reply;
1234 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1235 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1236 int32_t ret = service.HandleNotifyDataChange(data, reply);
1237
1238 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1239 }
1240
1241 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyEventChangeTest001, TestSize.Level1)
1242 {
1243 MockService service;
1244 MessageParcel data;
1245 MessageParcel reply;
1246 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1247 int32_t ret = service.HandleNotifyEventChange(data, reply);
1248
1249 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1250 }
1251
1252 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyEventChangeTest002, TestSize.Level1)
1253 {
1254 MockService service;
1255 MessageParcel data;
1256 MessageParcel reply;
1257 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1258 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1259 int32_t ret = service.HandleNotifyEventChange(data, reply);
1260
1261 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1262 }
1263
1264 HWTEST_F(CloudSyncServiceStubTest, HandleEnableCloudTest001, TestSize.Level1)
1265 {
1266 MockService service;
1267 MessageParcel data;
1268 MessageParcel reply;
1269 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1270 int32_t ret = service.HandleEnableCloud(data, reply);
1271
1272 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1273 }
1274
1275 HWTEST_F(CloudSyncServiceStubTest, HandleEnableCloudTest002, TestSize.Level1)
1276 {
1277 MockService service;
1278 MessageParcel data;
1279 MessageParcel reply;
1280 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1281 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1282 int32_t ret = service.HandleEnableCloud(data, reply);
1283
1284 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1285 }
1286
1287 HWTEST_F(CloudSyncServiceStubTest, HandleDisableCloudTest001, TestSize.Level1)
1288 {
1289 MockService service;
1290 MessageParcel data;
1291 MessageParcel reply;
1292 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1293 int32_t ret = service.HandleDisableCloud(data, reply);
1294
1295 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1296 }
1297
1298 HWTEST_F(CloudSyncServiceStubTest, HandleDisableCloudTest002, TestSize.Level1)
1299 {
1300 MockService service;
1301 MessageParcel data;
1302 MessageParcel reply;
1303 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1304 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1305 int32_t ret = service.HandleDisableCloud(data, reply);
1306
1307 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1308 }
1309
1310 HWTEST_F(CloudSyncServiceStubTest, HandleStartDownloadFileTest001, TestSize.Level1)
1311 {
1312 MockService service;
1313 MessageParcel data;
1314 MessageParcel reply;
1315 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1316 int32_t ret = service.HandleStartDownloadFile(data, reply);
1317
1318 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1319 }
1320
1321 HWTEST_F(CloudSyncServiceStubTest, HandleStartDownloadFileTest002, TestSize.Level1)
1322 {
1323 MockService service;
1324 MessageParcel data;
1325 MessageParcel reply;
1326 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1327 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1328 int32_t ret = service.HandleStartDownloadFile(data, reply);
1329
1330 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1331 }
1332
1333 HWTEST_F(CloudSyncServiceStubTest, HandleStartFileCacheTest001, TestSize.Level1)
1334 {
1335 MockService service;
1336 MessageParcel data;
1337 MessageParcel reply;
1338 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1339 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1340 int32_t ret = service.HandleStartFileCache(data, reply);
1341
1342 EXPECT_EQ(ret, E_OK);
1343 }
1344
1345 HWTEST_F(CloudSyncServiceStubTest, HandleStartFileCacheTest002, TestSize.Level1)
1346 {
1347 MockService service;
1348 MessageParcel data;
1349 MessageParcel reply;
1350 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1351 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1352 int32_t ret = service.HandleStartFileCache(data, reply);
1353
1354 EXPECT_EQ(ret, E_OK);
1355 }
1356
1357 HWTEST_F(CloudSyncServiceStubTest, HandleStopDownloadFileTest001, TestSize.Level1)
1358 {
1359 MockService service;
1360 MessageParcel data;
1361 MessageParcel reply;
1362 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1363 int32_t ret = service.HandleStopDownloadFile(data, reply);
1364
1365 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1366 }
1367
1368 HWTEST_F(CloudSyncServiceStubTest, HandleStopDownloadFileTest002, TestSize.Level1)
1369 {
1370 MockService service;
1371 MessageParcel data;
1372 MessageParcel reply;
1373 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1374 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1375 int32_t ret = service.HandleStopDownloadFile(data, reply);
1376
1377 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1378 }
1379
1380 HWTEST_F(CloudSyncServiceStubTest, HandleStopFileCacheTest001, TestSize.Level1)
1381 {
1382 MockService service;
1383 MessageParcel data;
1384 MessageParcel reply;
1385 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1386 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1387 int32_t ret = service.HandleStopFileCache(data, reply);
1388
1389 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1390 }
1391
1392 HWTEST_F(CloudSyncServiceStubTest, HandleStopFileCacheTest002, TestSize.Level1)
1393 {
1394 MockService service;
1395 MessageParcel data;
1396 MessageParcel reply;
1397 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1398 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1399 int32_t ret = service.HandleStopFileCache(data, reply);
1400
1401 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1402 }
1403
1404 HWTEST_F(CloudSyncServiceStubTest, HandleStopFileCacheTest003, TestSize.Level1)
1405 {
1406 MockService service;
1407 MessageParcel data;
1408 MessageParcel reply;
1409 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1410 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1411 int32_t ret = service.HandleStopFileCache(data, reply);
1412
1413 EXPECT_EQ(ret, E_OK);
1414 }
1415
1416 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadFileCallbackTest002, TestSize.Level1)
1417 {
1418 MockService service;
1419 MessageParcel data;
1420 MessageParcel reply;
1421 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1422 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1423 int32_t ret = service.HandleRegisterDownloadFileCallback(data, reply);
1424
1425 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1426 }
1427
1428 HWTEST_F(CloudSyncServiceStubTest, HandleUnregisterDownloadFileCallbackTest002, TestSize.Level1)
1429 {
1430 MockService service;
1431 MessageParcel data;
1432 MessageParcel reply;
1433 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1434 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1435 int32_t ret = service.HandleUnregisterDownloadFileCallback(data, reply);
1436
1437 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1438 }
1439
1440 HWTEST_F(CloudSyncServiceStubTest, HandleUploadAssetTest001, TestSize.Level1)
1441 {
1442 MockService service;
1443 MessageParcel data;
1444 MessageParcel reply;
1445 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1446 int32_t ret = service.HandleUploadAsset(data, reply);
1447
1448 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1449 }
1450
1451 HWTEST_F(CloudSyncServiceStubTest, HandleUploadAssetTest002, TestSize.Level1)
1452 {
1453 MockService service;
1454 MessageParcel data;
1455 MessageParcel reply;
1456 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1457 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1458 int32_t ret = service.HandleUploadAsset(data, reply);
1459
1460 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1461 }
1462
1463 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFileTest001, TestSize.Level1)
1464 {
1465 MockService service;
1466 MessageParcel data;
1467 MessageParcel reply;
1468 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1469 int32_t ret = service.HandleDownloadFile(data, reply);
1470
1471 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1472 }
1473
1474 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFileTest002, TestSize.Level1)
1475 {
1476 MockService service;
1477 MessageParcel data;
1478 MessageParcel reply;
1479 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1480 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1481 int32_t ret = service.HandleDownloadFile(data, reply);
1482
1483 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1484 }
1485
1486 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFilesTest001, TestSize.Level1)
1487 {
1488 MockService service;
1489 MessageParcel data;
1490 MessageParcel reply;
1491 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1492 int32_t ret = service.HandleDownloadFiles(data, reply);
1493
1494 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1495 }
1496
1497 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFilesTest002, TestSize.Level1)
1498 {
1499 MockService service;
1500 MessageParcel data;
1501 MessageParcel reply;
1502 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1503 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1504 int32_t ret = service.HandleDownloadFiles(data, reply);
1505
1506 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1507 }
1508
1509 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFilesTest003, TestSize.Level1)
1510 {
1511 MockService service;
1512 MessageParcel data;
1513 MessageParcel reply;
1514 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1515 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1516 int32_t ret = service.HandleDownloadFiles(data, reply);
1517
1518 EXPECT_EQ(ret, E_OK);
1519 }
1520
1521 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadAssetCallbackTest001, TestSize.Level1)
1522 {
1523 MockService service;
1524 MessageParcel data;
1525 MessageParcel reply;
1526 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1527 int32_t ret = service.HandleRegisterDownloadAssetCallback(data, reply);
1528
1529 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1530 }
1531
1532 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadAssetCallbackTest002, TestSize.Level1)
1533 {
1534 MockService service;
1535 MessageParcel data;
1536 MessageParcel reply;
1537 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1538 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1539 int32_t ret = service.HandleRegisterDownloadAssetCallback(data, reply);
1540
1541 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1542 }
1543
1544 HWTEST_F(CloudSyncServiceStubTest, HandleDeleteAssetTest001, TestSize.Level1)
1545 {
1546 MockService service;
1547 MessageParcel data;
1548 MessageParcel reply;
1549 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1550 int32_t ret = service.HandleDeleteAsset(data, reply);
1551
1552 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1553 }
1554
1555 HWTEST_F(CloudSyncServiceStubTest, HandleDeleteAssetTest002, TestSize.Level1)
1556 {
1557 MockService service;
1558 MessageParcel data;
1559 MessageParcel reply;
1560 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1561 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1562 int32_t ret = service.HandleDeleteAsset(data, reply);
1563
1564 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1565 }
1566
1567 HWTEST_F(CloudSyncServiceStubTest, HandleGetSyncTimeTest001, TestSize.Level1)
1568 {
1569 MockService service;
1570 MessageParcel data;
1571 MessageParcel reply;
1572 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1573 int32_t ret = service.HandleGetSyncTime(data, reply);
1574
1575 EXPECT_EQ(ret, E_OK);
1576 }
1577
1578 HWTEST_F(CloudSyncServiceStubTest, HandleGetSyncTimeTest002, TestSize.Level1)
1579 {
1580 MockService service;
1581 MessageParcel data;
1582 MessageParcel reply;
1583 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1584 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1585 int32_t ret = service.HandleGetSyncTime(data, reply);
1586
1587 EXPECT_EQ(ret, E_OK);
1588 }
1589
1590 HWTEST_F(CloudSyncServiceStubTest, HandleBatchDentryFileInsert001, TestSize.Level1)
1591 {
1592 MockService service;
1593 MessageParcel data;
1594 MessageParcel reply;
1595 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1596 int32_t ret = service.HandleBatchDentryFileInsert(data, reply);\
1597 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1598 }
1599
1600 HWTEST_F(CloudSyncServiceStubTest, HandleBatchDentryFileInsert002, TestSize.Level1)
1601 {
1602 MockService service;
1603 MessageParcel data;
1604 MessageParcel reply;
1605 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1606 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1607 int32_t ret = service.HandleBatchDentryFileInsert(data, reply);
1608 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1609 }
1610
1611 HWTEST_F(CloudSyncServiceStubTest, HandleBatchDentryFileInsert003, TestSize.Level1)
1612 {
1613 MockService service;
1614 MessageParcel data;
1615 MessageParcel reply;
1616 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1617 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1618 int32_t ret = service.HandleBatchDentryFileInsert(data, reply);
1619 EXPECT_EQ(ret, E_OK);
1620 }
1621
1622 HWTEST_F(CloudSyncServiceStubTest, HandleCleanCacheTest001, TestSize.Level1)
1623 {
1624 MockService service;
1625 MessageParcel data;
1626 MessageParcel reply;
1627 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1628 int32_t ret = service.HandleCleanCache(data, reply);
1629
1630 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1631 }
1632
1633 HWTEST_F(CloudSyncServiceStubTest, HandleCleanCacheTest002, TestSize.Level1)
1634 {
1635 MockService service;
1636 MessageParcel data;
1637 MessageParcel reply;
1638 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1639 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1640 int32_t ret = service.HandleCleanCache(data, reply);
1641
1642 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1643 }
1644
1645 HWTEST_F(CloudSyncServiceStubTest, HandleBatchCleanFileTest001, TestSize.Level1)
1646 {
1647 MockService service;
1648 MessageParcel data;
1649 MessageParcel reply;
1650 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(false));
1651 int32_t ret = service.HandleBatchCleanFile(data, reply);\
1652 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1653 }
1654
1655 HWTEST_F(CloudSyncServiceStubTest, HandleBatchCleanFileTest002, TestSize.Level1)
1656 {
1657 MockService service;
1658 MessageParcel data;
1659 MessageParcel reply;
1660 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1661 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(false));
1662 int32_t ret = service.HandleBatchCleanFile(data, reply);
1663 EXPECT_EQ(ret, E_PERMISSION_SYSTEM);
1664 }
1665
1666 HWTEST_F(CloudSyncServiceStubTest, HandleBatchCleanFileTest003, TestSize.Level1)
1667 {
1668 MockService service;
1669 MessageParcel data;
1670 MessageParcel reply;
1671 EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
1672 EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
1673 int32_t ret = service.HandleBatchCleanFile(data, reply);
1674 EXPECT_EQ(ret, E_OK);
1675 }
1676
1677 } // namespace Test
1678 } // namespace FileManagement::CloudSync
1679 } // namespace OHOS
1680