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 "data_handler.h"
20 #include "data_sync_manager.h"
21 #include "dfs_error.h"
22 #include "gallery_data_syncer.h"
23 #include "gmock/gmock-spec-builders.h"
24 #include "sync_rule/battery_status.h"
25 #include "sync_rule/cloud_status.h"
26
27 namespace OHOS::FileManagement::CloudSync::Test {
28 using namespace testing;
29 using namespace testing::ext;
30 using namespace std;
31
32 class DataHandlerMock final : public DataHandler {
33 public:
DataHandlerMock(int32_t userId,const std::string & bundleName,const std::string & table)34 DataHandlerMock(int32_t userId, const std::string &bundleName, const std::string &table)
35 : DataHandler(userId, bundleName, table)
36 {
37 }
38
39 MOCK_METHOD1(GetFetchCondition, void(FetchCondition &cond));
40 MOCK_METHOD2(OnFetchRecords, int32_t(std::shared_ptr<std::vector<DriveKit::DKRecord>> &, OnFetchParams &));
41 MOCK_METHOD1(GetRetryRecords, int32_t(std::vector<DriveKit::DKRecordId> &records));
42 MOCK_METHOD1(GetCreatedRecords, int32_t(std::vector<DriveKit::DKRecord> &records));
43 MOCK_METHOD1(GetDeletedRecords, int32_t(std::vector<DriveKit::DKRecord> &records));
44 MOCK_METHOD1(GetMetaModifiedRecords, int32_t(std::vector<DriveKit::DKRecord> &records));
45 MOCK_METHOD1(OnCreateRecords, int32_t(const std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> &map));
46 MOCK_METHOD1(OnDeleteRecords, int32_t(const std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> &map));
47 MOCK_METHOD1(OnModifyMdirtyRecords,
48 int32_t(const std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> &map));
49
50 public:
51 void GetReturnTest();
52 void OnRecordFailedTest();
53 void FinishPullTest();
54 void GetNextCursorTest();
55 };
56
GetReturnTest()57 void DataHandlerMock::GetReturnTest()
58 {
59 int32_t retCode;
60 int32_t error = E_STOP;
61 GetReturn(error, retCode);
62 EXPECT_EQ(retCode, E_STOP);
63 error = E_CLOUD_STORAGE_FULL;
64 GetReturn(error, retCode);
65 EXPECT_EQ(retCode, E_CLOUD_STORAGE_FULL);
66 error = E_SYNC_FAILED_NETWORK_NOT_AVAILABLE;
67 GetReturn(error, retCode);
68 EXPECT_EQ(retCode, E_SYNC_FAILED_NETWORK_NOT_AVAILABLE);
69 retCode = E_OK;
70 error = E_OK;
71 GetReturn(error, retCode);
72 EXPECT_EQ(retCode, E_OK);
73 }
74
OnRecordFailedTest()75 void DataHandlerMock::OnRecordFailedTest()
76 {
77 DriveKit::DKRecordOperResult result;
78 DriveKit::DKError error;
79 error.serverErrorCode = 0;
80 error.errorDetails.clear();
81 result.SetDKError(error);
82 auto ret = OnRecordFailed({"", result});
83 EXPECT_EQ(ret, E_INVAL_ARG);
84 GTEST_LOG_(INFO) << "OnRecordFailed other001";
85 DriveKit::DKErrorDetail detail;
86 detail.detailCode = 0;
87 error.errorDetails.push_back(detail);
88 result.SetDKError(error);
89 ret = OnRecordFailed({"", result});
90 EXPECT_EQ(ret, E_UNKNOWN);
91 GTEST_LOG_(INFO) << "OnRecordFailed other002";
92 detail.detailCode = static_cast<int>(DriveKit::DKDetailErrorCode::SPACE_FULL);
93 error.errorDetails.clear();
94 error.errorDetails.push_back(detail);
95 result.SetDKError(error);
96 ret = OnRecordFailed({"", result});
97 EXPECT_EQ(ret, E_CLOUD_STORAGE_FULL);
98 GTEST_LOG_(INFO) << "OnRecordFailed other003";
99 error.serverErrorCode = static_cast<int>(DriveKit::DKServerErrorCode::NETWORK_ERROR);
100 error.errorDetails.clear();
101 result.SetDKError(error);
102 ret = OnRecordFailed({"", result});
103 EXPECT_EQ(ret, E_SYNC_FAILED_NETWORK_NOT_AVAILABLE);
104 GTEST_LOG_(INFO) << "OnRecordFailed other004";
105 error.serverErrorCode = static_cast<int>(DriveKit::DKServerErrorCode::UID_EMPTY);
106 result.SetDKError(error);
107 ret = OnRecordFailed({"", result});
108 EXPECT_EQ(ret, E_STOP);
109 GTEST_LOG_(INFO) << "OnRecordFailed other005";
110 error.serverErrorCode = static_cast<int>(DriveKit::DKServerErrorCode::SWITCH_OFF);
111 result.SetDKError(error);
112 ret = OnRecordFailed({"", result});
113 EXPECT_EQ(ret, E_STOP);
114 }
115
FinishPullTest()116 void DataHandlerMock::FinishPullTest()
117 {
118 cursorMap_.clear();
119 cursorFinishMap_.insert({0, true});
120 isFinish_ = true;
121 startCursor_.clear();
122 FinishPull(0);
123 GTEST_LOG_(INFO) << "FinishPull other001";
124 cursorFinishMap_.clear();
125 startCursor_ = "test";
126 cursorFinishMap_.insert({1, true});
127 FinishPull(0);
128 GTEST_LOG_(INFO) << "FinishPull other002";
129 isFinish_ = false;
130 FinishPull(0);
131 GTEST_LOG_(INFO) << "FinishPull other003";
132 isFinish_ = false;
133 DriveKit::DKQueryCursor cursor;
134 cursorMap_.insert({1, cursor});
135 FinishPull(0);
136 }
GetNextCursorTest()137 void DataHandlerMock::GetNextCursorTest()
138 {
139 tempNextCursor_.clear();
140 DriveKit::DKQueryCursor cursor;
141 GetNextCursor(cursor);
142 EXPECT_EQ(cursor, "");
143 GTEST_LOG_(INFO) << "GetNextCursor other001";
144 tempNextCursor_ = "test";
145 GetNextCursor(cursor);
146 EXPECT_EQ(cursor, "test");
147 }
148
149 class DataHandlerTest : public testing::Test {
150 public:
151 static void SetUpTestCase(void);
152 static void TearDownTestCase(void);
153 void SetUp();
154 void TearDown();
155 static inline shared_ptr<DataHandlerMock> dataHandler_;
156 };
SetUpTestCase(void)157 void DataHandlerTest::SetUpTestCase(void)
158 {
159 GTEST_LOG_(INFO) << "SetUpTestCase";
160 string tableName = "test";
161 string bundleName = "com.ohos.test";
162 const int32_t userId = 100;
163 dataHandler_ = make_shared<DataHandlerMock>(userId, bundleName, tableName);
164 }
165
TearDownTestCase(void)166 void DataHandlerTest::TearDownTestCase(void)
167 {
168 GTEST_LOG_(INFO) << "TearDownTestCase";
169 dataHandler_ = nullptr;
170 }
171
SetUp(void)172 void DataHandlerTest::SetUp(void) {}
173
TearDown(void)174 void DataHandlerTest::TearDown(void) {}
175
176 /**
177 * @tc.name: GetNextCursorTest
178 * @tc.desc: Verify the GetNextCursor function
179 * @tc.type: FUNC
180 * @tc.require: #I7UVFF
181 */
182 HWTEST_F(DataHandlerTest, GetNextCursorTest, TestSize.Level1)
183 {
184 GTEST_LOG_(INFO) << "GetNextCursorTest Start";
185 try {
186 dataHandler_->GetNextCursorTest();
187 EXPECT_TRUE(true);
188 } catch (...) {
189 EXPECT_TRUE(false);
190 GTEST_LOG_(INFO) << "GetNextCursorTest FAILED";
191 }
192 GTEST_LOG_(INFO) << "GetNextCursorTest end";
193 }
194
195 /**
196 * @tc.name: SetTempStartCursorTest
197 * @tc.desc: Verify the SetTempStartCursor function
198 * @tc.type: FUNC
199 * @tc.require: #I7UVFF
200 */
201 HWTEST_F(DataHandlerTest, SetTempStartCursorTest, TestSize.Level1)
202 {
203 GTEST_LOG_(INFO) << "SetTempStartCursorTest Start";
204 try {
205 DriveKit::DKQueryCursor cursor = "test";
206 dataHandler_->SetTempStartCursor(cursor);
207 EXPECT_TRUE(true);
208 } catch (...) {
209 EXPECT_TRUE(false);
210 GTEST_LOG_(INFO) << "SetTempStartCursorTest FAILED";
211 }
212 GTEST_LOG_(INFO) << "SetTempStartCursorTest end";
213 }
214
215 /**
216 * @tc.name: GetTempStartCursorTest
217 * @tc.desc: Verify the GetTempStartCursor function
218 * @tc.type: FUNC
219 * @tc.require: #I7UVFF
220 */
221 HWTEST_F(DataHandlerTest, GetTempStartCursorTest, TestSize.Level1)
222 {
223 GTEST_LOG_(INFO) << "GetTempStartCursorTest Start";
224 try {
225 DriveKit::DKQueryCursor cursor;
226 dataHandler_->GetTempStartCursor(cursor);
227 EXPECT_EQ(cursor, "test");
228 } catch (...) {
229 EXPECT_TRUE(false);
230 GTEST_LOG_(INFO) << "GetTempStartCursorTest FAILED";
231 }
232 GTEST_LOG_(INFO) << "GetTempStartCursorTest end";
233 }
234
235 /**
236 * @tc.name: SetTempNextCursorTest
237 * @tc.desc: Verify the SetTempNextCursor function
238 * @tc.type: FUNC
239 * @tc.require: #I7UVFF
240 */
241 HWTEST_F(DataHandlerTest, SetTempNextCursorTest, TestSize.Level1)
242 {
243 GTEST_LOG_(INFO) << "SetTempNextCursorTest Start";
244 try {
245 DriveKit::DKQueryCursor cursor;
246 dataHandler_->SetTempNextCursor(cursor, true);
247 GTEST_LOG_(INFO) << "SetTempNextCursorTest other";
248 dataHandler_->SetTempNextCursor(cursor, false);
249 EXPECT_TRUE(true);
250 } catch (...) {
251 EXPECT_TRUE(false);
252 GTEST_LOG_(INFO) << "SetTempNextCursorTest FAILED";
253 }
254 GTEST_LOG_(INFO) << "SetTempNextCursorTest end";
255 }
256
257 /**
258 * @tc.name: GetBatchNoTest
259 * @tc.desc: Verify the GetBatchNo function
260 * @tc.type: FUNC
261 * @tc.require: #I7UVFF
262 */
263 HWTEST_F(DataHandlerTest, GetBatchNoTest, TestSize.Level1)
264 {
265 GTEST_LOG_(INFO) << "GetBatchNoTest Start";
266 try {
267 auto ret = dataHandler_->GetBatchNo();
268 EXPECT_EQ(ret, 1);
269 } catch (...) {
270 EXPECT_TRUE(false);
271 GTEST_LOG_(INFO) << "GetBatchNoTest FAILED";
272 }
273 GTEST_LOG_(INFO) << "GetBatchNoTest end";
274 }
275
276 /**
277 * @tc.name: IsPullRecordsTest
278 * @tc.desc: Verify the IsPullRecords function
279 * @tc.type: FUNC
280 * @tc.require: #I7UVFF
281 */
282 HWTEST_F(DataHandlerTest, IsPullRecordsTest, TestSize.Level1)
283 {
284 GTEST_LOG_(INFO) << "IsPullRecordsTest Start";
285 try {
286 auto ret = dataHandler_->IsPullRecords();
287 EXPECT_EQ(ret, true);
288 } catch (...) {
289 EXPECT_TRUE(false);
290 GTEST_LOG_(INFO) << "IsPullRecordsTest FAILED";
291 }
292 GTEST_LOG_(INFO) << "IsPullRecordsTest end";
293 }
294
295 /**
296 * @tc.name: ClearCursorTest
297 * @tc.desc: Verify the ClearCursor function
298 * @tc.type: FUNC
299 * @tc.require: #I7UVFF
300 */
301 HWTEST_F(DataHandlerTest, ClearCursorTest, TestSize.Level1)
302 {
303 GTEST_LOG_(INFO) << "ClearCursorTest Start";
304 try {
305 dataHandler_->ClearCursor();
306 EXPECT_TRUE(true);
307 } catch (...) {
308 EXPECT_TRUE(false);
309 GTEST_LOG_(INFO) << "ClearCursorTest FAILED";
310 }
311 GTEST_LOG_(INFO) << "ClearCursorTest end";
312 }
313
314 /**
315 * @tc.name: FinishPullTest
316 * @tc.desc: Verify the FinishPull function
317 * @tc.type: FUNC
318 * @tc.require: #I7UVFF
319 */
320 HWTEST_F(DataHandlerTest, FinishPullTest, TestSize.Level1)
321 {
322 GTEST_LOG_(INFO) << "FinishPullTest Start";
323 try {
324 dataHandler_->FinishPullTest();
325 EXPECT_TRUE(true);
326 } catch (...) {
327 EXPECT_TRUE(false);
328 GTEST_LOG_(INFO) << "FinishPullTest FAILED";
329 }
330 GTEST_LOG_(INFO) << "FinishPullTest end";
331 }
332
333 /**
334 * @tc.name: SetRecordSizeTest
335 * @tc.desc: Verify the SetRecordSize function
336 * @tc.type: FUNC
337 * @tc.require: #I7UVFF
338 */
339 HWTEST_F(DataHandlerTest, SetRecordSizeTest, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "SetRecordSizeTest Start";
342 try {
343 dataHandler_->SetRecordSize(1);
344 EXPECT_TRUE(true);
345 } catch (...) {
346 EXPECT_TRUE(false);
347 GTEST_LOG_(INFO) << "SetRecordSizeTest FAILED";
348 }
349 GTEST_LOG_(INFO) << "SetRecordSizeTest end";
350 }
351
352 /**
353 * @tc.name: GetRecordSizeTest
354 * @tc.desc: Verify the GetRecordSize function
355 * @tc.type: FUNC
356 * @tc.require: #I7UVFF
357 */
358 HWTEST_F(DataHandlerTest, GetRecordSizeTest, TestSize.Level1)
359 {
360 GTEST_LOG_(INFO) << "GetRecordSizeTest Start";
361 try {
362 auto ret = dataHandler_->GetRecordSize();
363 EXPECT_NE(ret, 0);
364 } catch (...) {
365 EXPECT_TRUE(false);
366 GTEST_LOG_(INFO) << "GetRecordSizeTest FAILED";
367 }
368 GTEST_LOG_(INFO) << "GetRecordSizeTest end";
369 }
370
371 /**
372 * @tc.name: GetCheckFlagTest
373 * @tc.desc: Verify the GetCheckFlag function
374 * @tc.type: FUNC
375 * @tc.require: #I7UVFF
376 */
377 HWTEST_F(DataHandlerTest, GetCheckFlagTest, TestSize.Level1)
378 {
379 GTEST_LOG_(INFO) << "GetCheckFlagTest Start";
380 try {
381 auto ret = dataHandler_->GetCheckFlag();
382 EXPECT_NE(ret, true);
383 } catch (...) {
384 EXPECT_TRUE(false);
385 GTEST_LOG_(INFO) << "GetCheckFlagTest FAILED";
386 }
387 GTEST_LOG_(INFO) << "GetCheckFlagTest end";
388 }
389
390 /**
391 * @tc.name: SetCheckingTest
392 * @tc.desc: Verify the SetChecking function
393 * @tc.type: FUNC
394 * @tc.require: #I7UVFF
395 */
396 HWTEST_F(DataHandlerTest, SetCheckingTest, TestSize.Level1)
397 {
398 GTEST_LOG_(INFO) << "SetCheckingTest Start";
399 try {
400 dataHandler_->SetChecking();
401 EXPECT_TRUE(true);
402 } catch (...) {
403 EXPECT_TRUE(false);
404 GTEST_LOG_(INFO) << "SetCheckingTest FAILED";
405 }
406 GTEST_LOG_(INFO) << "SetCheckingTest end";
407 }
408
409 /**
410 * @tc.name: GetCheckRecordsTest
411 * @tc.desc: Verify the GetCheckRecords function
412 * @tc.type: FUNC
413 * @tc.require: #I7UVFF
414 */
415 HWTEST_F(DataHandlerTest, GetCheckRecordsTest, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "GetCheckRecordsTest Start";
418 vector<DriveKit::DKRecordId> checkRecords;
419 auto ret = dataHandler_->GetCheckRecords(checkRecords, nullptr);
420 EXPECT_EQ(ret, E_OK);
421 GTEST_LOG_(INFO) << "GetCheckRecordsTest end";
422 }
423
424 /**
425 * @tc.name: GetFileModifiedRecordsTest
426 * @tc.desc: Verify the GetFileModifiedRecords function
427 * @tc.type: FUNC
428 * @tc.require: #I7UVFF
429 */
430 HWTEST_F(DataHandlerTest, GetFileModifiedRecordsTest, TestSize.Level1)
431 {
432 GTEST_LOG_(INFO) << "GetFileModifiedRecordsTest Start";
433 vector<DriveKit::DKRecord> records;
434 auto ret = dataHandler_->GetFileModifiedRecords(records);
435 EXPECT_EQ(ret, E_OK);
436 GTEST_LOG_(INFO) << "GetFileModifiedRecordsTest end";
437 }
438
439 /**
440 * @tc.name: OnModifyFdirtyRecordsTest
441 * @tc.desc: Verify the OnModifyFdirtyRecords function
442 * @tc.type: FUNC
443 * @tc.require: #I7UVFF
444 */
445 HWTEST_F(DataHandlerTest, OnModifyFdirtyRecordsTest, TestSize.Level1)
446 {
447 GTEST_LOG_(INFO) << "OnModifyFdirtyRecordsTest Start";
448 auto ret = dataHandler_->OnModifyFdirtyRecords({});
449 EXPECT_EQ(ret, E_OK);
450 GTEST_LOG_(INFO) << "OnModifyFdirtyRecordsTest end";
451 }
452
453 /**
454 * @tc.name: GetAssetsToDownloadTest
455 * @tc.desc: Verify the GetAssetsToDownload function
456 * @tc.type: FUNC
457 * @tc.require: #I7UVFF
458 */
459 HWTEST_F(DataHandlerTest, GetAssetsToDownloadTest, TestSize.Level1)
460 {
461 GTEST_LOG_(INFO) << "GetAssetsToDownloadTest Start";
462 vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
463 auto ret = dataHandler_->GetAssetsToDownload(outAssetsToDownload);
464 EXPECT_EQ(ret, E_OK);
465 GTEST_LOG_(INFO) << "GetAssetsToDownloadTest end";
466 }
467
468 /**
469 * @tc.name: GetDownloadAssetTest
470 * @tc.desc: Verify the GetDownloadAsset function
471 * @tc.type: FUNC
472 * @tc.require: #I7UVFF
473 */
474 HWTEST_F(DataHandlerTest, GetDownloadAssetTest, TestSize.Level1)
475 {
476 GTEST_LOG_(INFO) << "GetDownloadAssetTest Start";
477 vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
478 auto ret = dataHandler_->GetDownloadAsset("100", outAssetsToDownload);
479 EXPECT_EQ(ret, E_OK);
480 GTEST_LOG_(INFO) << "GetDownloadAssetTest end";
481 }
482
483 /**
484 * @tc.name: OnDownloadSuccessTest
485 * @tc.desc: Verify the OnDownloadSuccess function
486 * @tc.type: FUNC
487 * @tc.require: #I7UVFF
488 */
489 HWTEST_F(DataHandlerTest, OnDownloadSuccessTest, TestSize.Level1)
490 {
491 GTEST_LOG_(INFO) << "OnDownloadSuccessTest Start";
492 DriveKit::DKDownloadAsset asset;
493 auto ret = dataHandler_->OnDownloadSuccess(asset);
494 EXPECT_EQ(ret, E_OK);
495 GTEST_LOG_(INFO) << "OnDownloadSuccessTest end";
496 }
497
498 /**
499 * @tc.name: OnDownloadAssetsTest
500 * @tc.desc: Verify the OnDownloadAssets function
501 * @tc.type: FUNC
502 * @tc.require: #I7UVFF
503 */
504 HWTEST_F(DataHandlerTest, OnDownloadAssetsTest, TestSize.Level1)
505 {
506 GTEST_LOG_(INFO) << "OnDownloadAssetsTest Start";
507 map<DriveKit::DKDownloadAsset, DriveKit::DKDownloadResult> resultMap;
508 auto ret = dataHandler_->OnDownloadAssets(resultMap);
509 EXPECT_EQ(ret, E_OK);
510 GTEST_LOG_(INFO) << "OnDownloadAssetsTest end";
511 }
512
513 /**
514 * @tc.name: OnDownloadAssetsTest002
515 * @tc.desc: Verify the OnDownloadAssets function
516 * @tc.type: FUNC
517 * @tc.require: #I7UVFF
518 */
519 HWTEST_F(DataHandlerTest, OnDownloadAssetsTest002, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO) << "OnDownloadAssetsTest002 Start";
522 DriveKit::DKDownloadAsset asset;
523 auto ret = dataHandler_->OnDownloadAssets(asset);
524 EXPECT_EQ(ret, E_OK);
525 GTEST_LOG_(INFO) << "OnDownloadAssetsTest002 end";
526 }
527
528 /**
529 * @tc.name: CleanTest
530 * @tc.desc: Verify the Clean function
531 * @tc.type: FUNC
532 * @tc.require: #I7UVFF
533 */
534 HWTEST_F(DataHandlerTest, CleanTest, TestSize.Level1)
535 {
536 GTEST_LOG_(INFO) << "CleanTest Start";
537 auto ret = dataHandler_->Clean(100);
538 EXPECT_EQ(ret, E_OK);
539 GTEST_LOG_(INFO) << "CleanTest end";
540 }
541
542 /**
543 * @tc.name: OnRecordFailedTest
544 * @tc.desc: Verify the OnRecordFailed function
545 * @tc.type: FUNC
546 * @tc.require: #I7UVFF
547 */
548 HWTEST_F(DataHandlerTest, OnRecordFailedTest, TestSize.Level1)
549 {
550 GTEST_LOG_(INFO) << "OnRecordFailedTest Start";
551 dataHandler_->OnRecordFailedTest();
552 EXPECT_TRUE(true);
553 GTEST_LOG_(INFO) << "OnRecordFailedTest end";
554 }
555
556 /**
557 * @tc.name: HandleCloudSpaceNotEnoughTest
558 * @tc.desc: Verify the HandleCloudSpaceNotEnough function
559 * @tc.type: FUNC
560 * @tc.require: #I7UVFF
561 */
562 HWTEST_F(DataHandlerTest, HandleCloudSpaceNotEnoughTest, TestSize.Level1)
563 {
564 GTEST_LOG_(INFO) << "HandleCloudSpaceNotEnoughTest Start";
565 auto ret = dataHandler_->HandleCloudSpaceNotEnough();
566 EXPECT_EQ(ret, E_CLOUD_STORAGE_FULL);
567 GTEST_LOG_(INFO) << "HandleCloudSpaceNotEnoughTest end";
568 }
569
570 /**
571 * @tc.name: HandleNotSupportSyncTest
572 * @tc.desc: Verify the HandleNotSupportSync function
573 * @tc.type: FUNC
574 * @tc.require: #I7UVFF
575 */
576 HWTEST_F(DataHandlerTest, HandleNotSupportSyncTest, TestSize.Level1)
577 {
578 GTEST_LOG_(INFO) << "HandleNotSupportSyncTest Start";
579 auto ret = dataHandler_->HandleNotSupportSync();
580 EXPECT_EQ(ret, E_STOP);
581 GTEST_LOG_(INFO) << "HandleNotSupportSyncTest end";
582 }
583
584 /**
585 * @tc.name: HandleNetworkErrTest
586 * @tc.desc: Verify the HandleNetworkErr function
587 * @tc.type: FUNC
588 * @tc.require: #I7UVFF
589 */
590 HWTEST_F(DataHandlerTest, HandleNetworkErrTest, TestSize.Level1)
591 {
592 GTEST_LOG_(INFO) << "HandleNetworkErrTest Start";
593 auto ret = dataHandler_->HandleNetworkErr();
594 EXPECT_EQ(ret, E_SYNC_FAILED_NETWORK_NOT_AVAILABLE);
595 GTEST_LOG_(INFO) << "HandleNetworkErrTest end";
596 }
597
598 /**
599 * @tc.name: HandleDetailcodeTest
600 * @tc.desc: Verify the HandleDetailcode function
601 * @tc.type: FUNC
602 * @tc.require: #I7UVFF
603 */
604 HWTEST_F(DataHandlerTest, HandleDetailcodeTest, TestSize.Level1)
605 {
606 GTEST_LOG_(INFO) << "HandleDetailcodeTest Start";
607 auto ret = dataHandler_->HandleDetailcode({});
608 EXPECT_EQ(ret, E_UNKNOWN);
609 GTEST_LOG_(INFO) << "HandleDetailcodeTest end";
610 }
611
612 /**
613 * @tc.name: GetReturnTest
614 * @tc.desc: Verify the GetReturn function
615 * @tc.type: FUNC
616 * @tc.require: #I7UVFF
617 */
618 HWTEST_F(DataHandlerTest, GetReturnTest, TestSize.Level1)
619 {
620 GTEST_LOG_(INFO) << "GetReturnTest Start";
621 dataHandler_->GetReturnTest();
622 EXPECT_TRUE(true);
623 GTEST_LOG_(INFO) << "GetReturnTest end";
624 }
625 } // namespace OHOS::FileManagement::CloudSync::Test