• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "dfs_error.h"
20 #include "file_data_convertor.h"
21 #include "gallery_file_const.h"
22 #include "medialibrary_db_const.h"
23 #include "result_set_mock.h"
24 #include "thumbnail_const.h"
25 #include "data_sync_const.h"
26 
27 namespace OHOS::FileManagement::CloudSync::Test {
28 using namespace testing;
29 using namespace testing::ext;
30 using namespace std;
31 using namespace NativeRdb;
32 using namespace Media;
33 
34 class FileDataConvertorTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40     shared_ptr<FileDataConvertor> fileDataConvertor_;
41 };
SetUpTestCase(void)42 void FileDataConvertorTest::SetUpTestCase(void)
43 {
44     GTEST_LOG_(INFO) << "SetUpTestCase";
45 }
46 
TearDownTestCase(void)47 void FileDataConvertorTest::TearDownTestCase(void)
48 {
49     GTEST_LOG_(INFO) << "TearDownTestCase";
50 }
51 
SetUp(void)52 void FileDataConvertorTest::SetUp(void)
53 {
54     GTEST_LOG_(INFO) << "SetUp";
55     int32_t userId = 100;
56     string bundleName = "com.ohos.test";
57     OperationType Type = OperationType::FILE_CREATE;
58     fileDataConvertor_ = make_shared<FileDataConvertor>(userId, bundleName, Type);
59 }
60 
TearDown(void)61 void FileDataConvertorTest::TearDown(void)
62 {
63     GTEST_LOG_(INFO) << "TearDown";
64 }
65 
66 HWTEST_F(FileDataConvertorTest, FillRecordIdTest, TestSize.Level1)
67 {
68     DriveKit::DKRecord record;
69     ResultSetMock resultSet;
70     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
71     auto ret = fileDataConvertor_->FillRecordId(record, resultSet);
72     EXPECT_EQ(E_RDB, ret);
73 }
74 
75 HWTEST_F(FileDataConvertorTest, FillRecordIdTest1, TestSize.Level1)
76 {
77     DriveKit::DKRecord record;
78     ResultSetMock resultSet;
79     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
80     EXPECT_CALL(resultSet, GetString(_, _)).WillOnce(Return(0));
81     auto ret = fileDataConvertor_->FillRecordId(record, resultSet);
82     EXPECT_EQ(E_OK, ret);
83 }
84 
85 
86 HWTEST_F(FileDataConvertorTest, HandleAlbumIdTest, TestSize.Level1)
87 {
88     DriveKit::DKRecordData data;
89     ResultSetMock resultSet;
90     string key = "albumId";
91     auto ret = fileDataConvertor_->HandleAlbumId(data, resultSet);
92     EXPECT_EQ(E_OK, ret);
93 }
94 
95 HWTEST_F(FileDataConvertorTest, HandleHashTest, TestSize.Level1)
96 {
97     DriveKit::DKRecordData data;
98     ResultSetMock resultSet;
99     string key = "hashId";
100     auto ret = fileDataConvertor_->HandleHash(data, resultSet);
101     EXPECT_EQ(E_OK, ret);
102 }
103 
104 HWTEST_F(FileDataConvertorTest, HandleFileNameTest, TestSize.Level1)
105 {
106     DriveKit::DKRecordData data;
107     ResultSetMock resultSet;
108     string key = "fileName";
109     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
110     auto ret = fileDataConvertor_->HandleFileName(data, resultSet);
111     EXPECT_EQ(E_RDB, ret);
112 }
113 
114 HWTEST_F(FileDataConvertorTest, HandleFileNameTest1, TestSize.Level1)
115 {
116     DriveKit::DKRecordData data;
117     ResultSetMock resultSet;
118     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
119     EXPECT_CALL(resultSet, GetString(_, _)).WillOnce(Return(0));
120     string key = "fileName";
121     auto ret = fileDataConvertor_->HandleFileName(data, resultSet);
122     EXPECT_EQ(E_OK, ret);
123 }
124 
125 HWTEST_F(FileDataConvertorTest, HandleSourceTest, TestSize.Level1)
126 {
127     DriveKit::DKRecordData data;
128     ResultSetMock resultSet;
129     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
130     EXPECT_CALL(resultSet, GetString(_, _)).WillOnce(Return(0));
131     auto ret = fileDataConvertor_->HandleSource(data, resultSet);
132     EXPECT_EQ(E_OK, ret);
133 }
134 
135 HWTEST_F(FileDataConvertorTest, HandleCreatedTimeTest, TestSize.Level1)
136 {
137     DriveKit::DKRecordData data;
138     ResultSetMock resultSet;
139     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
140     string key = "createdTime";
141     auto ret = fileDataConvertor_->HandleCreatedTime(data, resultSet);
142     EXPECT_EQ(E_RDB, ret);
143 }
144 
145 HWTEST_F(FileDataConvertorTest, HandleCreatedTimeTest1, TestSize.Level1)
146 {
147     DriveKit::DKRecordData data;
148     ResultSetMock resultSet;
149     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
150     EXPECT_CALL(resultSet, GetLong(_, _)).WillOnce(Return(0));
151     string key = "createdTime";
152     auto ret = fileDataConvertor_->HandleCreatedTime(data, resultSet);
153     EXPECT_EQ(E_OK, ret);
154 }
155 
156 HWTEST_F(FileDataConvertorTest, HandleFavoriteTest, TestSize.Level1)
157 {
158     DriveKit::DKRecordData data;
159     ResultSetMock resultSet;
160     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
161     string key = "favorite";
162     auto ret = fileDataConvertor_->HandleFavorite(data, resultSet);
163     EXPECT_EQ(E_RDB, ret);
164 }
165 
166 HWTEST_F(FileDataConvertorTest, HandleFavoriteTest1, TestSize.Level1)
167 {
168     DriveKit::DKRecordData data;
169     ResultSetMock resultSet;
170     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
171     EXPECT_CALL(resultSet, GetInt(_, _)).WillOnce(Return(0));
172     string key = "favorite";
173     auto ret = fileDataConvertor_->HandleFavorite(data, resultSet);
174     EXPECT_EQ(E_OK, ret);
175 }
176 
177 HWTEST_F(FileDataConvertorTest, HandleRecycleTest, TestSize.Level1)
178 {
179     DriveKit::DKRecordData data;
180     ResultSetMock resultSet;
181     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
182     string key = "recycled";
183     auto ret = fileDataConvertor_->HandleRecycleTime(data, resultSet);
184     EXPECT_EQ(E_RDB, ret);
185 }
186 
187 HWTEST_F(FileDataConvertorTest, HandleRecycleTest1, TestSize.Level1)
188 {
189     DriveKit::DKRecordData data;
190     ResultSetMock resultSet;
191     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
192     EXPECT_CALL(resultSet, GetLong(_, _)).WillOnce(Return(0));
193     string key = "recycled";
194     auto ret = fileDataConvertor_->HandleRecycleTime(data, resultSet);
195     EXPECT_EQ(E_OK, ret);
196 }
197 
198 HWTEST_F(FileDataConvertorTest, HandleDescriptionTest, TestSize.Level1)
199 {
200     DriveKit::DKRecordData data;
201     ResultSetMock resultSet;
202     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
203     string key = "description";
204     auto ret = fileDataConvertor_->HandleDescription(data, resultSet);
205     EXPECT_TRUE(E_OK == ret || E_RDB == ret);
206 }
207 
208 HWTEST_F(FileDataConvertorTest, HandlePropertiesTest, TestSize.Level1)
209 {
210     DriveKit::DKRecordData data;
211     ResultSetMock resultSet;
212     auto ret = fileDataConvertor_->HandleProperties(data, resultSet);
213     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
214     EXPECT_CALL(resultSet,  GetString(_, _)).WillRepeatedly(Return(0));
215     EXPECT_CALL(resultSet,  GetLong(_, _)).WillRepeatedly(Return(0));
216     EXPECT_CALL(resultSet,  GetDouble(_, _)).WillRepeatedly(Return(0));
217     EXPECT_CALL(resultSet,  GetInt(_, _)).WillRepeatedly(Return(0));
218     EXPECT_EQ(E_OK, ret);
219 }
220 
221 HWTEST_F(FileDataConvertorTest, HandlePositionTest, TestSize.Level1)
222 {
223     DriveKit::DKRecordFieldMap map;
224     ResultSetMock resultSet;
225     string key = "position";
226     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
227     EXPECT_CALL(resultSet,  GetDouble(_, _)).WillRepeatedly(Return(0));
228     auto ret = fileDataConvertor_->HandlePosition(map, resultSet);
229     EXPECT_EQ(E_OK, ret);
230 }
231 
232 HWTEST_F(FileDataConvertorTest, HandleHeightTest, TestSize.Level1)
233 {
234     DriveKit::DKRecordFieldMap map;
235     ResultSetMock resultSet;
236     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
237     string key = "height";
238     auto ret = fileDataConvertor_->HandleHeight(map, resultSet);
239     EXPECT_EQ(E_RDB, ret);
240 }
241 
242 HWTEST_F(FileDataConvertorTest, HandleHeightTest1, TestSize.Level1)
243 {
244     DriveKit::DKRecordFieldMap map;
245     ResultSetMock resultSet;
246     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
247     EXPECT_CALL(resultSet, GetInt(_, _)).WillOnce(Return(0));
248     string key = "height";
249     auto ret = fileDataConvertor_->HandleHeight(map, resultSet);
250     EXPECT_EQ(E_OK, ret);
251 }
252 
253 HWTEST_F(FileDataConvertorTest, HandleRotateTest, TestSize.Level1)
254 {
255     DriveKit::DKRecordFieldMap map;
256     ResultSetMock resultSet;
257     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
258     string key = "rotation";
259     auto ret = fileDataConvertor_->HandleRotate(map, resultSet);
260     EXPECT_EQ(E_RDB, ret);
261 }
262 
263 HWTEST_F(FileDataConvertorTest, HandleRotateTest1, TestSize.Level1)
264 {
265     DriveKit::DKRecordFieldMap map;
266     ResultSetMock resultSet;
267     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
268     EXPECT_CALL(resultSet, GetInt(_, _)).WillOnce(Return(0));
269     string key = "rotation";
270     auto ret = fileDataConvertor_->HandleRotate(map, resultSet);
271     EXPECT_EQ(E_OK, ret);
272 }
273 
274 HWTEST_F(FileDataConvertorTest, HandleWidthTest, TestSize.Level1)
275 {
276     DriveKit::DKRecordFieldMap map;
277     ResultSetMock resultSet;
278     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
279     string key = "width";
280     auto ret = fileDataConvertor_->HandleWidth(map, resultSet);
281     EXPECT_EQ(E_RDB, ret);
282 }
283 
284 HWTEST_F(FileDataConvertorTest, HandleWidthTest1, TestSize.Level1)
285 {
286     DriveKit::DKRecordFieldMap map;
287     ResultSetMock resultSet;
288     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
289     EXPECT_CALL(resultSet, GetInt(_, _)).WillOnce(Return(0));
290     string key = "width";
291     auto ret = fileDataConvertor_->HandleWidth(map, resultSet);
292     EXPECT_EQ(E_OK, ret);
293 }
294 
295 HWTEST_F(FileDataConvertorTest, HandleDataModifiedTest, TestSize.Level1)
296 {
297     DriveKit::DKRecordFieldMap map;
298     ResultSetMock resultSet;
299     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
300     string key = "data_modified";
301     auto ret = fileDataConvertor_->HandleDataModified(map, resultSet);
302     EXPECT_EQ(E_RDB, ret);
303 }
304 
305 HWTEST_F(FileDataConvertorTest, HandleDataModifiedTest1, TestSize.Level1)
306 {
307     DriveKit::DKRecordFieldMap map;
308     ResultSetMock resultSet;
309     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
310     EXPECT_CALL(resultSet, GetLong(_, _)).WillOnce(Return(0));
311     string key = "data_modified";
312     auto ret = fileDataConvertor_->HandleDataModified(map, resultSet);
313     EXPECT_EQ(E_OK, ret);
314 }
315 
316 HWTEST_F(FileDataConvertorTest, HandleDetailTimeTest, TestSize.Level1)
317 {
318     DriveKit::DKRecordFieldMap map;
319     ResultSetMock resultSet;
320     string key = "detail_time";
321     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
322     EXPECT_CALL(resultSet, GetLong(_, _)).WillOnce(Return(0));
323     auto ret = fileDataConvertor_->HandleDetailTime(map, resultSet);
324     EXPECT_EQ(E_OK, ret);
325 }
326 
327 HWTEST_F(FileDataConvertorTest, HandleFileCreateTimeTest, TestSize.Level1)
328 {
329     DriveKit::DKRecordFieldMap map;
330     ResultSetMock resultSet;
331     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
332     string key = "fileCreateTime";
333     auto ret = fileDataConvertor_->HandleFileCreateTime(map, resultSet);
334     EXPECT_EQ(E_RDB, ret);
335 }
336 
337 HWTEST_F(FileDataConvertorTest, HandleFileCreateTimeTest1, TestSize.Level1)
338 {
339     DriveKit::DKRecordFieldMap map;
340     ResultSetMock resultSet;
341     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
342     EXPECT_CALL(resultSet, GetLong(_, _)).WillOnce(Return(0));
343     string key = "fileCreateTime";
344     auto ret = fileDataConvertor_->HandleFileCreateTime(map, resultSet);
345     EXPECT_EQ(E_OK, ret);
346 }
347 
348 HWTEST_F(FileDataConvertorTest, HandleFirstUpdateTimeTest, TestSize.Level1)
349 {
350     DriveKit::DKRecordFieldMap map;
351     ResultSetMock resultSet;
352     string key = "first_update_time";
353     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
354     EXPECT_CALL(resultSet, GetLong(_, _)).WillOnce(Return(0));
355     auto ret = fileDataConvertor_->HandleFirstUpdateTime(map, resultSet);
356     EXPECT_EQ(E_OK, ret);
357 }
358 
359 HWTEST_F(FileDataConvertorTest, HandleRelativeBucketIdTest, TestSize.Level1)
360 {
361     DriveKit::DKRecordFieldMap map;
362     ResultSetMock resultSet;
363     string key = "relative_bucket_id";
364     auto ret = fileDataConvertor_->HandleRelativeBucketId(map, resultSet);
365     EXPECT_EQ(E_OK, ret);
366 }
367 
368 HWTEST_F(FileDataConvertorTest, HandleSourceFileNameTest, TestSize.Level1)
369 {
370     DriveKit::DKRecordFieldMap map;
371     ResultSetMock resultSet;
372     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
373     string key = "sourceFileName";
374     auto ret = fileDataConvertor_->HandleSourceFileName(map, resultSet);
375     EXPECT_EQ(E_RDB, ret);
376 }
377 
378 HWTEST_F(FileDataConvertorTest, HandleSourceFileNameTest1, TestSize.Level1)
379 {
380     DriveKit::DKRecordFieldMap map;
381     ResultSetMock resultSet;
382     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
383     EXPECT_CALL(resultSet, GetString(_, _)).WillOnce(Return(0));
384     string key = "sourceFileName";
385     auto ret = fileDataConvertor_->HandleSourceFileName(map, resultSet);
386     EXPECT_EQ(E_OK, ret);
387 }
388 
389 HWTEST_F(FileDataConvertorTest, HandleSourcePathTest, TestSize.Level1)
390 {
391     DriveKit::DKRecordFieldMap map;
392     ResultSetMock resultSet;
393     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
394     string key = "sourcePath";
395     auto ret = fileDataConvertor_->HandleSourcePath(map, resultSet);
396     EXPECT_EQ(E_RDB, ret);
397 }
398 
399 HWTEST_F(FileDataConvertorTest, HandleSourcePathTest1, TestSize.Level1)
400 {
401     DriveKit::DKRecordFieldMap map;
402     ResultSetMock resultSet;
403     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
404     EXPECT_CALL(resultSet, GetString(_, _)).WillOnce(Return(0));
405     string key = "sourcePath";
406     auto ret = fileDataConvertor_->HandleSourcePath(map, resultSet);
407     EXPECT_EQ(E_OK, ret);
408 }
409 
410 HWTEST_F(FileDataConvertorTest, HandleTimeZoneTest, TestSize.Level1)
411 {
412     DriveKit::DKRecordFieldMap map;
413     ResultSetMock resultSet;
414     string key = "time_zone";
415     auto ret = fileDataConvertor_->HandleTimeZone(map, resultSet);
416     EXPECT_EQ(E_OK, ret);
417 }
418 
419 HWTEST_F(FileDataConvertorTest, HandleContentTest, TestSize.Level1)
420 {
421     DriveKit::DKRecordData data;
422     string path;
423     auto ret = fileDataConvertor_->HandleContent(data, path);
424     EXPECT_EQ(E_PATH, ret);
425 }
426 
427 HWTEST_F(FileDataConvertorTest, HandleThumbnailTest, TestSize.Level1)
428 {
429     DriveKit::DKRecordData data;
430     string path;
431     auto ret = fileDataConvertor_->HandleThumbnail(data, path);
432     EXPECT_EQ(E_PATH, ret);
433 }
434 
435 HWTEST_F(FileDataConvertorTest, HandleLcdTest, TestSize.Level1)
436 {
437     DriveKit::DKRecordData data;
438     string path;
439     auto ret = fileDataConvertor_->HandleLcd(data, path);
440     EXPECT_EQ(E_PATH, ret);
441 }
442 
443 HWTEST_F(FileDataConvertorTest, HandleGeneralTest, TestSize.Level1)
444 {
445     DriveKit::DKRecordFieldMap map;
446     ResultSetMock resultSet;
447     string key = "general";
448     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
449     EXPECT_CALL(resultSet,  GetString(_, _)).WillRepeatedly(Return(0));
450     EXPECT_CALL(resultSet,  GetLong(_, _)).WillRepeatedly(Return(0));
451     EXPECT_CALL(resultSet,  GetDouble(_, _)).WillRepeatedly(Return(0));
452     EXPECT_CALL(resultSet,  GetInt(_, _)).WillRepeatedly(Return(0));
453     auto ret = fileDataConvertor_->HandleGeneral(map, resultSet);
454     EXPECT_EQ(E_OK, ret);
455 }
456 
457 HWTEST_F(FileDataConvertorTest, HandleAttachmentsTest, TestSize.Level1)
458 {
459     DriveKit::DKRecordData data;
460     ResultSetMock resultSet;
461     string key = "attachments";
462     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(1));
463     auto ret = fileDataConvertor_->HandleAttachments(data, resultSet);
464     EXPECT_EQ(E_RDB, ret);
465 }
466 
467 HWTEST_F(FileDataConvertorTest, HandleAttachments1Test, TestSize.Level1)
468 {
469     DriveKit::DKRecordData data;
470     ResultSetMock resultSet;
471     string key = "attachments";
472     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillOnce(Return(0));
473     EXPECT_CALL(resultSet, GetString(_, _)).WillOnce(Return(0));
474     auto ret = fileDataConvertor_->HandleAttachments(data, resultSet);
475     EXPECT_EQ(E_PATH, ret);
476 }
477 
478 HWTEST_F(FileDataConvertorTest, HandleAttachments2Test, TestSize.Level1)
479 {
480     DriveKit::DKRecordData data;
481     ResultSetMock resultSet;
482     string key = "attachments";
483     fileDataConvertor_->type_ = OperationType::FILE_METADATA_MODIFY;
484     auto ret = fileDataConvertor_->HandleAttachments(data, resultSet);
485     EXPECT_EQ(E_OK, ret);
486 }
487 
488 HWTEST_F(FileDataConvertorTest, ConvertTest, TestSize.Level1)
489 {
490     DriveKit::DKRecord record;
491     ResultSetMock resultSet;
492     fileDataConvertor_->type_ = OperationType::FILE_CREATE;
493     EXPECT_CALL(resultSet, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
494     EXPECT_CALL(resultSet,  GetString(_, _)).WillRepeatedly(Return(0));
495     EXPECT_CALL(resultSet,  GetLong(_, _)).WillRepeatedly(Return(0));
496     EXPECT_CALL(resultSet,  GetDouble(_, _)).WillRepeatedly(Return(0));
497     EXPECT_CALL(resultSet,  GetInt(_, _)).WillRepeatedly(Return(0));
498     auto ret = fileDataConvertor_->Convert(record, resultSet);
499     EXPECT_EQ(E_PATH, ret);
500 }
501 
502 HWTEST_F(FileDataConvertorTest, GetLowerPathTest, TestSize.Level1)
503 {
504     string path = "";
505     auto ret = fileDataConvertor_->GetLowerPath(path);
506     string out = "";
507     EXPECT_EQ(out, ret);
508 }
509 
510 HWTEST_F(FileDataConvertorTest, GetLowerPathTest1, TestSize.Level1)
511 {
512     string path = "/storage/cloud/files/1";
513     auto ret = fileDataConvertor_->GetLowerPath(path);
514     string out = "/data/service/el2/100/hmdfs/account/files/1";
515     EXPECT_EQ(out, ret);
516 }
517 
518 HWTEST_F(FileDataConvertorTest, GetLowerTmpPathTest, TestSize.Level1)
519 {
520     string path = "";
521     auto ret = fileDataConvertor_->GetLowerTmpPath(path);
522     string out = "";
523     EXPECT_EQ(out, ret);
524 }
525 
526 HWTEST_F(FileDataConvertorTest, GetLowerTmpPathTest1, TestSize.Level1)
527 {
528     string path = "/storage/cloud/files/1";
529     auto ret = fileDataConvertor_->GetLowerTmpPath(path);
530     string out = "/data/service/el2/100/hmdfs/account/files/1.temp.download";
531     EXPECT_EQ(out, ret);
532 }
533 
534 HWTEST_F(FileDataConvertorTest, GetSandboxPathTest, TestSize.Level1)
535 {
536     string path = "";
537     auto ret = fileDataConvertor_->GetSandboxPath(path);
538     string out = "";
539     EXPECT_EQ(out, ret);
540 }
541 
542 HWTEST_F(FileDataConvertorTest, GetSandboxPathTest1, TestSize.Level1)
543 {
544     string path = "/data/service/el2/100/hmdfs/account/files/1";
545     auto ret = fileDataConvertor_->GetSandboxPath(path);
546     string out = "/storage/cloud/files/1";
547     EXPECT_EQ(out, ret);
548 }
549 
550 HWTEST_F(FileDataConvertorTest, GetThumbPathTest, TestSize.Level1)
551 {
552     string key;
553     string path = "";
554     auto ret = fileDataConvertor_->GetThumbPath(path, key);
555     string out = "";
556     EXPECT_EQ(out, ret);
557 }
558 
559 HWTEST_F(FileDataConvertorTest, GetThumbPathTest1, TestSize.Level1)
560 {
561     string key;
562     string path = "/storage/cloud/files/1";
563     auto ret = fileDataConvertor_->GetThumbPath(path, key);
564     string out = "/mnt/hmdfs/100/account/device_view/local/files/.thumbs/1/.jpg";
565     EXPECT_EQ(out, ret);
566 }
567 
568 HWTEST_F(FileDataConvertorTest, CompensateDataTest1, TestSize.Level1)
569 {
570     DriveKit::DKRecordData data;
571     NativeRdb::ValuesBucket valueBucket;
572     auto ret = fileDataConvertor_->CompensateData(data, valueBucket);
573     EXPECT_EQ(E_INVAL_ARG, ret);
574 }
575 
576 HWTEST_F(FileDataConvertorTest, CompensateDataTest2, TestSize.Level1)
577 {
578     DriveKit::DKRecordData data;
579     NativeRdb::ValuesBucket valueBucket;
580     DriveKit::DKRecordFieldMap fieldValue1;
581     fieldValue1[PhotoColumn::MEDIA_FILE_PATH] = DriveKit::DKRecordField();
582     DriveKit::DKFieldValue fieldValue = fieldValue1;
583     data[FILE_PROPERTIES] = DriveKit::DKRecordField(fieldValue);
584     auto ret = fileDataConvertor_->CompensateData(data, valueBucket);
585     EXPECT_EQ(E_INVAL_ARG, ret);
586 }
587 
588 HWTEST_F(FileDataConvertorTest, CompensateTitleTest1, TestSize.Level1)
589 {
590     DriveKit::DKRecordData data;
591     NativeRdb::ValuesBucket valueBucket;
592     auto ret = fileDataConvertor_->CompensateTitle(data, valueBucket);
593     EXPECT_EQ(E_OK, ret);
594 }
595 
596 HWTEST_F(FileDataConvertorTest, CompensateTitleTest2, TestSize.Level1)
597 {
598     DriveKit::DKRecordData data;
599     NativeRdb::ValuesBucket valueBucket;
600     data[FILE_PROPERTIES] = DriveKit::DKRecordField();
601     auto ret = fileDataConvertor_->CompensateTitle(data, valueBucket);
602     EXPECT_EQ(E_OK, ret);
603 }
604 
605 HWTEST_F(FileDataConvertorTest, CompensateTitleTest3, TestSize.Level1)
606 {
607     DriveKit::DKRecordData data;
608     NativeRdb::ValuesBucket valueBucket;
609     DriveKit::DKRecordFieldMap fieldValue1;
610     fieldValue1[FILE_SOURCE_FILE_NAME] = DriveKit::DKRecordField();
611     DriveKit::DKFieldValue fieldValue = fieldValue1;
612     data[FILE_PROPERTIES] = DriveKit::DKRecordField(fieldValue);
613     auto ret = fileDataConvertor_->CompensateTitle(data, valueBucket);
614     EXPECT_EQ(E_INVAL_ARG, ret);
615 }
616 
617 HWTEST_F(FileDataConvertorTest, CompensateMediaTypeTest1, TestSize.Level1)
618 {
619     DriveKit::DKRecordData data;
620     NativeRdb::ValuesBucket valueBucket;
621     auto ret = fileDataConvertor_->CompensateMediaType(data, valueBucket);
622     EXPECT_EQ(E_INVAL_ARG, ret);
623 }
624 
625 HWTEST_F(FileDataConvertorTest, CompensateMediaTypeeTest2, TestSize.Level1)
626 {
627     DriveKit::DKRecordData data;
628     NativeRdb::ValuesBucket valueBucket;
629     DriveKit::DKRecordFieldMap fieldValue1;
630     fieldValue1[FILE_FILETYPE] = DriveKit::DKRecordField();
631     DriveKit::DKFieldValue fieldValue = fieldValue1;
632     data[FILE_FILETYPE] = DriveKit::DKRecordField(fieldValue);
633     auto ret = fileDataConvertor_->CompensateMediaType(data, valueBucket);
634     EXPECT_EQ(E_INVAL_ARG, ret);
635 }
636 
637 HWTEST_F(FileDataConvertorTest, CompensateSubtypeTest1, TestSize.Level1)
638 {
639     DriveKit::DKRecordData data;
640     NativeRdb::ValuesBucket valueBucket;
641     auto ret = fileDataConvertor_->CompensateSubtype(data, valueBucket);
642     EXPECT_EQ(E_OK, ret);
643 }
644 
645 HWTEST_F(FileDataConvertorTest, CompensateSubtypeTest2, TestSize.Level1)
646 {
647     DriveKit::DKRecordData data;
648     NativeRdb::ValuesBucket valueBucket;
649     data[FILE_PROPERTIES] = DriveKit::DKRecordField();
650     auto ret = fileDataConvertor_->CompensateSubtype(data, valueBucket);
651     EXPECT_EQ(E_OK, ret);
652 }
653 
654 HWTEST_F(FileDataConvertorTest, CompensateSubtypeTest3, TestSize.Level1)
655 {
656     DriveKit::DKRecordData data;
657     NativeRdb::ValuesBucket valueBucket;
658     DriveKit::DKRecordFieldMap fieldValue1;
659     fieldValue1[FILE_SOURCE_PATH] = DriveKit::DKRecordField();
660     DriveKit::DKFieldValue fieldValue = fieldValue1;
661     data[FILE_PROPERTIES] = DriveKit::DKRecordField(fieldValue);
662     auto ret = fileDataConvertor_->CompensateSubtype(data, valueBucket);
663     EXPECT_EQ(E_OK, ret);
664 }
665 
666 HWTEST_F(FileDataConvertorTest, CompensateDurationTest1, TestSize.Level1)
667 {
668     DriveKit::DKRecordData data;
669     NativeRdb::ValuesBucket valueBucket;
670     auto ret = fileDataConvertor_->CompensateDuration(data, valueBucket);
671     EXPECT_EQ(E_OK, ret);
672 }
673 
674 HWTEST_F(FileDataConvertorTest, CompensateDurationTest2, TestSize.Level1)
675 {
676     DriveKit::DKRecordData data;
677     NativeRdb::ValuesBucket valueBucket;
678     data[FILE_PROPERTIES] = DriveKit::DKRecordField();
679     auto ret = fileDataConvertor_->CompensateDuration(data, valueBucket);
680     EXPECT_EQ(E_OK, ret);
681 }
682 
683 HWTEST_F(FileDataConvertorTest, CompensateDurationTest3, TestSize.Level1)
684 {
685     DriveKit::DKRecordData data;
686     NativeRdb::ValuesBucket valueBucket;
687     DriveKit::DKRecordFieldMap fieldValue1;
688     fieldValue1[FILE_DURATION] = DriveKit::DKRecordField();
689     DriveKit::DKFieldValue fieldValue = fieldValue1;
690     data[FILE_PROPERTIES] = DriveKit::DKRecordField(fieldValue);
691     auto ret = fileDataConvertor_->CompensateDuration(data, valueBucket);
692     EXPECT_EQ(E_OK, ret);
693 }
694 
695 HWTEST_F(FileDataConvertorTest, ExtractCompatibleValueTest1, TestSize.Level1)
696 {
697     DriveKit::DKRecord record;
698     DriveKit::DKRecordData data;
699     NativeRdb::ValuesBucket valueBucket;
700     auto ret = fileDataConvertor_->ExtractCompatibleValue(record, data, valueBucket);
701     EXPECT_EQ(E_OK, ret);
702 }
703 
704 HWTEST_F(FileDataConvertorTest, ExtractOrientationTest1, TestSize.Level1)
705 {
706     DriveKit::DKRecordFieldMap map;
707     NativeRdb::ValuesBucket valueBucket;
708     auto ret = fileDataConvertor_->ExtractOrientation(map, valueBucket);
709     EXPECT_EQ(E_OK, ret);
710 }
711 
712 HWTEST_F(FileDataConvertorTest, ExtractOrientationTest2, TestSize.Level1)
713 {
714     DriveKit::DKRecordFieldMap map;
715     NativeRdb::ValuesBucket valueBucket;
716     DriveKit::DKRecordFieldMap fieldValue1;
717     fieldValue1[FILE_ROTATION] = DriveKit::DKRecordField();
718     DriveKit::DKFieldValue fieldValue = fieldValue1;
719     map[FILE_ROTATION] = DriveKit::DKRecordField(fieldValue);
720     auto ret = fileDataConvertor_->ExtractOrientation(map, valueBucket);
721     EXPECT_EQ(E_INVAL_ARG, ret);
722 }
723 
724 HWTEST_F(FileDataConvertorTest, ExtractPositionTest1, TestSize.Level1)
725 {
726     DriveKit::DKRecordFieldMap map;
727     NativeRdb::ValuesBucket valueBucket;
728     auto ret = fileDataConvertor_->ExtractPosition(map, valueBucket);
729     EXPECT_EQ(E_OK, ret);
730 }
731 
732 HWTEST_F(FileDataConvertorTest, ExtractPositionTest2, TestSize.Level1)
733 {
734     DriveKit::DKRecordFieldMap map;
735     NativeRdb::ValuesBucket valueBucket;
736     DriveKit::DKRecordFieldMap fieldValue1;
737     fieldValue1[FILE_POSITION] = DriveKit::DKRecordField();
738     DriveKit::DKFieldValue fieldValue = fieldValue1;
739     map[FILE_POSITION] = DriveKit::DKRecordField(fieldValue);
740     auto ret = fileDataConvertor_->ExtractPosition(map, valueBucket);
741     EXPECT_EQ(E_INVAL_ARG, ret);
742 }
743 
744 HWTEST_F(FileDataConvertorTest, ExtractHeightTest1, TestSize.Level1)
745 {
746     DriveKit::DKRecordFieldMap map;
747     NativeRdb::ValuesBucket valueBucket;
748     auto ret = fileDataConvertor_->ExtractHeight(map, valueBucket);
749     EXPECT_EQ(E_OK, ret);
750 }
751 
752 HWTEST_F(FileDataConvertorTest, ExtractHeightTest2, TestSize.Level1)
753 {
754     DriveKit::DKRecordFieldMap map;
755     NativeRdb::ValuesBucket valueBucket;
756     DriveKit::DKRecordFieldMap fieldValue1;
757     fieldValue1[FILE_HEIGHT] = DriveKit::DKRecordField();
758     DriveKit::DKFieldValue fieldValue = fieldValue1;
759     map[FILE_HEIGHT] = DriveKit::DKRecordField(fieldValue);
760     auto ret = fileDataConvertor_->ExtractHeight(map, valueBucket);
761     EXPECT_EQ(E_INVAL_ARG, ret);
762 }
763 
764 HWTEST_F(FileDataConvertorTest, ExtractWidthTest1, TestSize.Level1)
765 {
766     DriveKit::DKRecordFieldMap map;
767     NativeRdb::ValuesBucket valueBucket;
768     auto ret = fileDataConvertor_->ExtractWidth(map, valueBucket);
769     EXPECT_EQ(E_OK, ret);
770 }
771 
772 HWTEST_F(FileDataConvertorTest, ExtractWidthTest2, TestSize.Level1)
773 {
774     DriveKit::DKRecordFieldMap map;
775     NativeRdb::ValuesBucket valueBucket;
776     DriveKit::DKRecordFieldMap fieldValue1;
777     fieldValue1[FILE_WIDTH] = DriveKit::DKRecordField();
778     DriveKit::DKFieldValue fieldValue = fieldValue1;
779     map[FILE_WIDTH] = DriveKit::DKRecordField(fieldValue);
780     auto ret = fileDataConvertor_->ExtractWidth(map, valueBucket);
781     EXPECT_EQ(E_INVAL_ARG, ret);
782 }
783 
784 HWTEST_F(FileDataConvertorTest, ExtractSizeTest1, TestSize.Level1)
785 {
786     DriveKit::DKRecordData data;
787     NativeRdb::ValuesBucket valueBucket;
788     auto ret = fileDataConvertor_->ExtractSize(data, valueBucket);
789     EXPECT_EQ(E_OK, ret);
790 }
791 
792 HWTEST_F(FileDataConvertorTest, ExtractSizeTest2, TestSize.Level1)
793 {
794     DriveKit::DKRecordFieldMap map;
795     NativeRdb::ValuesBucket valueBucket;
796     DriveKit::DKRecordFieldMap fieldValue1;
797     fieldValue1[FILE_SIZE] = DriveKit::DKRecordField();
798     DriveKit::DKFieldValue fieldValue = fieldValue1;
799     map[FILE_SIZE] = DriveKit::DKRecordField(fieldValue);
800     auto ret = fileDataConvertor_->ExtractSize(map, valueBucket);
801     EXPECT_EQ(E_INVAL_ARG, ret);
802 }
803 
804 HWTEST_F(FileDataConvertorTest, ExtractDisplayNameTest1, TestSize.Level1)
805 {
806     DriveKit::DKRecordData data;
807     NativeRdb::ValuesBucket valueBucket;
808     auto ret = fileDataConvertor_->ExtractDisplayName(data, valueBucket);
809     EXPECT_EQ(E_OK, ret);
810 }
811 
812 HWTEST_F(FileDataConvertorTest, ExtractDisplayNameTest2, TestSize.Level1)
813 {
814     DriveKit::DKRecordData data;
815     NativeRdb::ValuesBucket valueBucket;
816     DriveKit::DKRecordFieldMap fieldValue1;
817     fieldValue1[FILE_FILE_NAME] = DriveKit::DKRecordField();
818     DriveKit::DKFieldValue fieldValue = fieldValue1;
819     data[FILE_FILE_NAME] = DriveKit::DKRecordField(fieldValue);
820     auto ret = fileDataConvertor_->ExtractDisplayName(data, valueBucket);
821     EXPECT_EQ(E_INVAL_ARG, ret);
822 }
823 
824 HWTEST_F(FileDataConvertorTest, ExtractMimeTypeTest1, TestSize.Level1)
825 {
826     DriveKit::DKRecordData data;
827     NativeRdb::ValuesBucket valueBucket;
828     auto ret = fileDataConvertor_->ExtractMimeType(data, valueBucket);
829     EXPECT_EQ(E_OK, ret);
830 }
831 
832 HWTEST_F(FileDataConvertorTest, ExtractMimeTypeTest2, TestSize.Level1)
833 {
834     DriveKit::DKRecordData data;
835     NativeRdb::ValuesBucket valueBucket;
836     DriveKit::DKRecordFieldMap fieldValue1;
837     fieldValue1[FILE_MIME_TYPE] = DriveKit::DKRecordField();
838     DriveKit::DKFieldValue fieldValue = fieldValue1;
839     data[FILE_MIME_TYPE] = DriveKit::DKRecordField(fieldValue);
840     auto ret = fileDataConvertor_->ExtractMimeType(data, valueBucket);
841     EXPECT_EQ(E_INVAL_ARG, ret);
842 }
843 
844 HWTEST_F(FileDataConvertorTest, ExtractDeviceNameTest1, TestSize.Level1)
845 {
846     DriveKit::DKRecordData data;
847     NativeRdb::ValuesBucket valueBucket;
848     auto ret = fileDataConvertor_->ExtractDeviceName(data, valueBucket);
849     EXPECT_EQ(E_OK, ret);
850 }
851 
852 HWTEST_F(FileDataConvertorTest, ExtractDeviceNameTest2, TestSize.Level1)
853 {
854     DriveKit::DKRecordData data;
855     NativeRdb::ValuesBucket valueBucket;
856     DriveKit::DKRecordFieldMap fieldValue1;
857     fieldValue1[FILE_SOURCE] = DriveKit::DKRecordField();
858     DriveKit::DKFieldValue fieldValue = fieldValue1;
859     data[FILE_SOURCE] = DriveKit::DKRecordField(fieldValue);
860     auto ret = fileDataConvertor_->ExtractDeviceName(data, valueBucket);
861     EXPECT_EQ(E_INVAL_ARG, ret);
862 }
863 
864 HWTEST_F(FileDataConvertorTest, ExtractFavoriteTest1, TestSize.Level1)
865 {
866     DriveKit::DKRecordData data;
867     NativeRdb::ValuesBucket valueBucket;
868     auto ret = fileDataConvertor_->ExtractFavorite(data, valueBucket);
869     EXPECT_EQ(E_OK, ret);
870 }
871 
872 HWTEST_F(FileDataConvertorTest, ExtractDateTrashedTest1, TestSize.Level1)
873 {
874     DriveKit::DKRecordData data;
875     NativeRdb::ValuesBucket valueBucket;
876     auto ret = fileDataConvertor_->ExtractDateTrashed(data, valueBucket);
877     EXPECT_EQ(E_OK, ret);
878 }
879 } // namespace OHOS::FileManagement::CloudSync::Test