1 /*
2  * Copyright (C) 2022-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 "medialibrary_helper_test.h"
17 
18 #include <fcntl.h>
19 #include <fstream>
20 #include <iterator>
21 
22 #include "media_file_uri.h"
23 #include "media_file_utils.h"
24 #include "media_log.h"
25 #include "medialibrary_db_const.h"
26 #include "medialibrary_type_const.h"
27 #include "medialibrary_errno.h"
28 #include "userfile_manager_types.h"
29 
30 using namespace std;
31 using namespace testing::ext;
32 
33 namespace OHOS {
34 namespace Media {
35 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsFileExists_Test_001, TestSize.Level0)
36 {
37     string filePath = "/data/test/isfileexists_001";
38     EXPECT_EQ(MediaFileUtils::IsFileExists(filePath), false);
39 }
40 
41 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsDirEmpty_Test_001, TestSize.Level0)
42 {
43     string dirPath = "/data/test/isdirempty_001";
44     EXPECT_EQ(MediaFileUtils::IsDirEmpty(dirPath), false);
45 }
46 
47 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsDirEmpty_Test_002, TestSize.Level0)
48 {
49     string dirPath = "/data/test/isdirempty_002";
50     string subPath = dirPath + "/isdirempty_002";
51     EXPECT_EQ(MediaFileUtils::CreateDirectory(subPath), true);
52     EXPECT_EQ(MediaFileUtils::IsDirEmpty(dirPath), false);
53 }
54 
55 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsDirEmpty_Test_003, TestSize.Level0)
56 {
57     string dirPath = "/data/test/isdirempty_003";
58     EXPECT_EQ(MediaFileUtils::CreateDirectory(dirPath), true);
59     EXPECT_EQ(MediaFileUtils::IsDirEmpty(dirPath), true);
60 }
61 
62 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CreateFile_Test_001, TestSize.Level0)
63 {
64     string filePath = "/data/test/createfile_001";
65     EXPECT_EQ(MediaFileUtils::CreateFile(filePath), true);
66 }
67 
68 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CreateFile_Test_002, TestSize.Level0)
69 {
70     string filePath = "";
71     EXPECT_EQ(MediaFileUtils::CreateFile(filePath), false);
72 }
73 
74 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CreateFile_Test_003, TestSize.Level0)
75 {
76     string filePath = "/data/test/createfile_003";
77     EXPECT_EQ(MediaFileUtils::CreateFile(filePath), true);
78     EXPECT_EQ(MediaFileUtils::CreateFile(filePath), false);
79 }
80 
81 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CreateFile_Test_004, TestSize.Level0)
82 {
83     string filePath = "/data/test/test/test/test/createfile_004";
84     EXPECT_EQ(MediaFileUtils::CreateFile(filePath), false);
85 }
86 
87 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_DeleteFile_Test_001, TestSize.Level0)
88 {
89     string filePath = "/data/test/deletefile_001";
90     EXPECT_EQ(MediaFileUtils::DeleteFile(filePath), false);
91 }
92 
93 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_DeleteDir_Test_001, TestSize.Level0)
94 {
95     string dirPath = "/data/test/deletedir_001";
96     EXPECT_EQ(MediaFileUtils::CreateDirectory(dirPath), true);
97     EXPECT_EQ(MediaFileUtils::DeleteDir(dirPath), true);
98 }
99 
100 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_DeleteDir_Test_002, TestSize.Level0)
101 {
102     string dirPath = "/data/test/deletedir_002";
103     EXPECT_EQ(MediaFileUtils::DeleteDir(dirPath), false);
104 }
105 
106 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_MoveFile_Test_001, TestSize.Level0)
107 {
108     string oldPath = "/data/test/movefile_001";
109     string newPath = "/data/test/movefile_001_move";
110     EXPECT_EQ(MediaFileUtils::CreateFile(oldPath), true);
111     EXPECT_EQ(MediaFileUtils::MoveFile(oldPath, newPath), true);
112 }
113 
114 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_MoveFile_Test_002, TestSize.Level0)
115 {
116     string oldPath = "/data/test/movefile_002";
117     string newPath = "/data/test/movefile_002_move";
118     EXPECT_EQ(MediaFileUtils::CreateFile(oldPath), true);
119     EXPECT_EQ(MediaFileUtils::CreateFile(newPath), true);
120     EXPECT_EQ(MediaFileUtils::MoveFile(oldPath, newPath), false);
121 }
122 
123 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_MoveFile_Test_003, TestSize.Level0)
124 {
125     string oldPath = "/data/test/movefile_003";
126     string newPath = "/data/test/movefile_003_move";
127     EXPECT_EQ(MediaFileUtils::MoveFile(oldPath, newPath), false);
128 }
129 
130 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CreateDirectory_Test_001, TestSize.Level0)
131 {
132     string dirPath = "/data/test/createdir_001";
133     EXPECT_EQ(MediaFileUtils::CreateDirectory(dirPath), true);
134 }
135 
CheckFileString(const string & filePath,const string & text)136 static bool CheckFileString(const string &filePath, const string &text)
137 {
138     ifstream inputFile(filePath);
139     if (inputFile.is_open()) {
140         string context((istreambuf_iterator<char>(inputFile)), (istreambuf_iterator<char>()));
141         inputFile.close();
142         if (context == text) {
143             return true;
144         } else {
145             return false;
146         }
147     } else {
148         return false;
149     }
150 }
151 
152 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_WriteStrToFile_Test_001, TestSize.Level0)
153 {
154     string testString = "123456";
155     string testPath = "/data/test/WriteStrToFileTest_001";
156     EXPECT_EQ(MediaFileUtils::WriteStrToFile("", testString), false);
157     EXPECT_EQ(MediaFileUtils::WriteStrToFile(testPath, ""), false);
158     EXPECT_EQ(MediaFileUtils::WriteStrToFile(testPath, testString), false);
159     EXPECT_EQ(MediaFileUtils::CreateFile(testPath), true);
160     EXPECT_EQ(MediaFileUtils::WriteStrToFile(testPath, ""), false);
161     EXPECT_EQ(MediaFileUtils::WriteStrToFile(testPath, testString), true);
162     EXPECT_EQ(CheckFileString(testPath, testString), true);
163 }
164 
165 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CopyByFd_Test_001, TestSize.Level0)
166 {
167     string oldPath = "/data/test/CopyByFd_001";
168     string newPath = "/data/test/CopyByFd_002";
169     string testString = "123456";
170 
171     EXPECT_EQ(MediaFileUtils::CreateFile(oldPath), true);
172     EXPECT_EQ(MediaFileUtils::CreateFile(newPath), true);
173     EXPECT_EQ(MediaFileUtils::WriteStrToFile(oldPath, testString), true);
174 
175     int32_t rfd = open(oldPath.c_str(), O_RDONLY);
176     int32_t wfd = open(newPath.c_str(), O_RDWR);
177     EXPECT_EQ(MediaFileUtils::CopyFile(rfd, wfd), true);
178     close(rfd);
179     close(wfd);
180     EXPECT_EQ(CheckFileString(newPath, testString), true);
181 }
182 
183 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_RenameDir_Test_001, TestSize.Level0)
184 {
185     string oldPath = "/data/test/renamedir_001";
186     string newPath = "/data/test/renamedir_001_renamed";
187     EXPECT_EQ(MediaFileUtils::CreateDirectory(oldPath), true);
188     EXPECT_EQ(MediaFileUtils::RenameDir(oldPath, newPath), true);
189 }
190 
191 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_RenameDir_Test_002, TestSize.Level0)
192 {
193     string oldPath = "/data/test/renamedir_002";
194     string newPath = "";
195     EXPECT_EQ(MediaFileUtils::CreateDirectory(oldPath), true);
196     EXPECT_EQ(MediaFileUtils::RenameDir(oldPath, newPath), false);
197 }
198 
199 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetFileTitle_test_001, TestSize.Level0)
200 {
201     string displayName = "";
202     string ret = MediaFileUtils::GetTitleFromDisplayName(displayName);
203     EXPECT_EQ(ret, "");
204     displayName = "medialib.test";
205     ret = MediaFileUtils::GetTitleFromDisplayName(displayName);
206     EXPECT_NE(ret, "");
207     displayName = "medialib.";
208     ret = MediaFileUtils::GetTitleFromDisplayName(displayName);
209     EXPECT_NE(ret, "");
210 }
211 
212 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckDisplayName_Test_001, TestSize.Level0)
213 {
214     string displayName = "";
215     EXPECT_LT(MediaFileUtils::CheckDisplayName(displayName), 0);
216 }
217 
218 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckDisplayName_Test_002, TestSize.Level0)
219 {
220     string displayName = ".nofile";
221     EXPECT_LT(MediaFileUtils::CheckDisplayName(displayName), 0);
222 }
223 
224 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckDisplayName_Test_003, TestSize.Level0)
225 {
226     string displayName = "test";
227     EXPECT_LT(MediaFileUtils::CheckDisplayName(displayName), 0);
228 }
229 
230 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckDisplayName_Test_004, TestSize.Level0)
231 {
232     string displayName = "test:*\'";
233     EXPECT_LT(MediaFileUtils::CheckDisplayName(displayName), 0);
234 }
235 
236 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckDisplayName_Test_005, TestSize.Level0)
237 {
238     string displayName = "test.test.jpg";
239     EXPECT_LT(MediaFileUtils::CheckDisplayName(displayName), 0);
240 }
241 
242 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckDisplayName_Test_006, TestSize.Level0)
243 {
244     string displayName = "test.jpg";
245     EXPECT_EQ(MediaFileUtils::CheckDisplayName(displayName), 0);
246 }
247 
248 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckFileDisplayName_Test_001, TestSize.Level0)
249 {
250     string displayName = "test.test.jpg";
251     EXPECT_EQ(MediaFileUtils::CheckFileDisplayName(displayName), 0);
252 }
253 
254 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetAlbumDateModified_Test_001, TestSize.Level0)
255 {
256     string dirPath = "/data/test/getalbumdatemodified_001";
257     EXPECT_EQ(MediaFileUtils::CreateDirectory(dirPath), true);
258     EXPECT_EQ(MediaFileUtils::GetAlbumDateModified(dirPath) > 0, true);
259 }
260 
261 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetAlbumDateModified_Test_002, TestSize.Level0)
262 {
263     string dirPath = "";
264     EXPECT_EQ(MediaFileUtils::GetAlbumDateModified(dirPath), 0);
265 }
266 
267 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetAlbumDateModified_Test_003, TestSize.Level0)
268 {
269     string dirPath = "/data/test/getalbumdatemodified_003";
270     EXPECT_EQ(MediaFileUtils::GetAlbumDateModified(dirPath), 0);
271 }
272 
273 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_UTCTimeSeconds_Test_001, TestSize.Level0)
274 {
275     EXPECT_EQ(MediaFileUtils::UTCTimeSeconds() > 0, true);
276 }
277 
278 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetNetworkIdFromUri_Test_001, TestSize.Level0)
279 {
280     string tempNetworkId = "1d3cb099659d53b3ee15faaab3c00a8ff983382ebc8b01aabde039ed084e167b";
281     string uri = MEDIALIBRARY_DATA_ABILITY_PREFIX + tempNetworkId + MEDIALIBRARY_DATA_URI_IDENTIFIER;
282     EXPECT_EQ(MediaFileUtils::GetNetworkIdFromUri(uri), tempNetworkId);
283 }
284 
285 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetNetworkIdFromUri_Test_002, TestSize.Level0)
286 {
287     string uri = "";
288     EXPECT_EQ(MediaFileUtils::GetNetworkIdFromUri(uri), "");
289 }
290 
291 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetNetworkIdFromUri_Test_003, TestSize.Level0)
292 {
293     string uri = MEDIALIBRARY_DATA_URI_IDENTIFIER;
294     EXPECT_EQ(MediaFileUtils::GetNetworkIdFromUri(uri), "");
295 }
296 
297 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetNetworkIdFromUri_Test_004, TestSize.Level0)
298 {
299     string uri = MEDIALIBRARY_DATA_ABILITY_PREFIX;
300     EXPECT_EQ(MediaFileUtils::GetNetworkIdFromUri(uri), "");
301 }
302 
303 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetNetworkIdFromUri_Test_005, TestSize.Level0)
304 {
305     string uri = MEDIALIBRARY_DATA_ABILITY_PREFIX + MEDIALIBRARY_DATA_URI_IDENTIFIER;
306     EXPECT_EQ(MediaFileUtils::GetNetworkIdFromUri(uri), "");
307 }
308 
309 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_UpdatePath_Test_002, TestSize.Level0)
310 {
311     string path = "";
312     string uri = "";
313     EXPECT_EQ(MediaFileUtils::UpdatePath(path, uri), path);
314 }
315 
316 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_UpdatePath_Test_003, TestSize.Level0)
317 {
318     string path = "/storage/cloud/100/files";
319     string uri = MEDIALIBRARY_DATA_ABILITY_PREFIX + MEDIALIBRARY_DATA_URI_IDENTIFIER;
320     EXPECT_EQ(MediaFileUtils::UpdatePath(path, uri), path);
321 }
322 
323 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_UpdatePath_Test_005, TestSize.Level0)
324 {
325     string path = "local/files";
326     string tempNetworkId = "1d3cb099659d53b3ee15faaab3c00a8ff983382ebc8b01aabde039ed084e167b";
327     string uri = MEDIALIBRARY_DATA_ABILITY_PREFIX + tempNetworkId + MEDIALIBRARY_DATA_URI_IDENTIFIER;
328     EXPECT_EQ(MediaFileUtils::UpdatePath(path, uri), path);
329 }
330 
331 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_UpdatePath_Test_006, TestSize.Level0)
332 {
333     string path = "/storage/cloud/100";
334     string tempNetworkId = "1d3cb099659d53b3ee15faaab3c00a8ff983382ebc8b01aabde039ed084e167b";
335     string uri = MEDIALIBRARY_DATA_ABILITY_PREFIX + tempNetworkId + MEDIALIBRARY_DATA_URI_IDENTIFIER;
336     EXPECT_EQ(MediaFileUtils::UpdatePath(path, uri), path);
337 }
338 
339 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_UpdatePath_Test_007, TestSize.Level0)
340 {
341     string path = "/storage/cloud/100";
342     string uri = "";
343     EXPECT_EQ(MediaFileUtils::UpdatePath(path, uri), path);
344 }
345 
346 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMediaType_Test_001, TestSize.Level0)
347 {
348     string displayName = "";
349     EXPECT_EQ(MediaFileUtils::GetMediaType(displayName), MEDIA_TYPE_ALL);
350 }
351 
352 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMediaType_Test_002, TestSize.Level0)
353 {
354     string displayName = "test";
355     EXPECT_EQ(MediaFileUtils::GetMediaType(displayName), MEDIA_TYPE_FILE);
356 }
357 
358 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMediaType_Test_003, TestSize.Level0)
359 {
360     string displayName = "test.mp3";
361     EXPECT_EQ(MediaFileUtils::GetMediaType(displayName), MEDIA_TYPE_AUDIO);
362 }
363 
364 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMediaType_Test_004, TestSize.Level0)
365 {
366     string displayName = "test.mp4";
367     EXPECT_EQ(MediaFileUtils::GetMediaType(displayName), MEDIA_TYPE_VIDEO);
368 }
369 
370 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMediaType_Test_005, TestSize.Level0)
371 {
372     string displayName = "test.jpg";
373     EXPECT_EQ(MediaFileUtils::GetMediaType(displayName), MEDIA_TYPE_IMAGE);
374 }
375 
376 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMediaType_Test_006, TestSize.Level0)
377 {
378     string displayName = "test.txt";
379     EXPECT_EQ(MediaFileUtils::GetMediaType(displayName), MEDIA_TYPE_FILE);
380 }
381 
382 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetFilename_Test_001, TestSize.Level0)
383 {
384     string filePath = "";
385     EXPECT_EQ(MediaFileUtils::GetFileName(filePath), "");
386 }
387 
388 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetFilename_Test_002, TestSize.Level0)
389 {
390     string filePath = "test";
391     EXPECT_EQ(MediaFileUtils::GetFileName(filePath), "");
392 }
393 
394 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetFilename_Test_003, TestSize.Level0)
395 {
396     string filePath = "test/";
397     EXPECT_EQ(MediaFileUtils::GetFileName(filePath), "");
398 }
399 
400 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetFilename_Test_004, TestSize.Level0)
401 {
402     string filePath = "test/test";
403     EXPECT_EQ(MediaFileUtils::GetFileName(filePath), "test");
404 }
405 
406 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsFileTablePath_Test_001, TestSize.Level0)
407 {
408     string filePath = "";
409     EXPECT_EQ(MediaFileUtils::IsFileTablePath(filePath), false);
410 }
411 
412 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsFileTablePath_Test_002, TestSize.Level0)
413 {
414     string filePath = "/1234546541315645464545165";
415     EXPECT_EQ(MediaFileUtils::IsFileTablePath(filePath), false);
416 }
417 
418 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsFileTablePath_Test_003, TestSize.Level0)
419 {
420     string filePath = ROOT_MEDIA_DIR;
421     EXPECT_EQ(MediaFileUtils::IsFileTablePath(filePath), false);
422 }
423 
424 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsFileTablePath_Test_004, TestSize.Level0)
425 {
426     string filePath = ROOT_MEDIA_DIR + DOCS_PATH;
427     EXPECT_EQ(MediaFileUtils::IsFileTablePath(filePath), true);
428     filePath = ROOT_MEDIA_DIR + AUDIO_DIR_VALUES;
429     EXPECT_EQ(MediaFileUtils::IsFileTablePath(filePath), false);
430 }
431 
432 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsPhotoTablePath_Test_001, TestSize.Level0)
433 {
434     string filePath = "";
435     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), false);
436 }
437 
438 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsPhotoTablePath_Test_002, TestSize.Level0)
439 {
440     string filePath = "/1234546541315645464545165";
441     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), false);
442 }
443 
444 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsPhotoTablePath_Test_003, TestSize.Level0)
445 {
446     string filePath = ROOT_MEDIA_DIR;
447     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), false);
448 }
449 
450 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsPhotoTablePath_Test_004, TestSize.Level0)
451 {
452     string filePath = ROOT_MEDIA_DIR + PHOTO_BUCKET;
453     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), true);
454     filePath = ROOT_MEDIA_DIR + PIC_DIR_VALUES;
455     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), true);
456     filePath = ROOT_MEDIA_DIR + VIDEO_DIR_VALUES;
457     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), true);
458     filePath = ROOT_MEDIA_DIR + CAMERA_DIR_VALUES;
459     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), true);
460 }
461 
462 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsPhotoTablePath_Test_005, TestSize.Level0)
463 {
464     string filePath = ROOT_MEDIA_DIR + AUDIO_DIR_VALUES;
465     EXPECT_EQ(MediaFileUtils::IsPhotoTablePath(filePath), false);
466 }
467 
468 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_001, TestSize.Level0)
469 {
470     const string virtualUri = "file://media/image/12";
471     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
472     EXPECT_EQ(realUri, "file://media/image/3");
473 }
474 
475 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_002, TestSize.Level0)
476 {
477     const string virtualUri = "file://media/audio/12";
478     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
479     EXPECT_EQ(realUri, "file://media/audio/3");
480 }
481 
482 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_003, TestSize.Level0)
483 {
484     const string virtualUri = "file://media/video/12";
485     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
486     EXPECT_EQ(realUri, "file://media/video/3");
487 }
488 
489 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_004, TestSize.Level0)
490 {
491     const string virtualUri = "file://media/Photo/12/VID_2023_001/VID_2023.jpg";
492     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
493     EXPECT_EQ(realUri, virtualUri);
494 }
495 
496 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_005, TestSize.Level0)
497 {
498     const string virtualUri = "file://media/Audio/12/VID_169_001/VID_2023.mp3";
499     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
500     EXPECT_EQ(realUri, virtualUri);
501 }
502 
503 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_006, TestSize.Level0)
504 {
505     const string virtualUri = "file://com.demo.a/data/storage/e12/base/files/12.txt";
506     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
507     EXPECT_EQ(realUri, virtualUri);
508 }
509 
510 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_007, TestSize.Level0)
511 {
512     const string virtualUri = "file://docs/storage/Users/currentUsers/Documents/12.txt";
513     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
514     EXPECT_EQ(realUri, virtualUri);
515 }
516 
517 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_008, TestSize.Level0)
518 {
519     const string virtualUri = "file://docs/storage/Users/currentUsers/Desktop/12.txt";
520     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
521     EXPECT_EQ(realUri, virtualUri);
522 }
523 
524 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_009, TestSize.Level0)
525 {
526     const string virtualUri = "file://docs/storage/Users/currentUsers/Download/12.txt";
527     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
528     EXPECT_EQ(realUri, virtualUri);
529 }
530 
531 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_010, TestSize.Level0)
532 {
533     const string virtualUri = "file://docs/storage/External/12.txt";
534     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
535     EXPECT_EQ(realUri, virtualUri);
536 }
537 
538 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetRealUriFromVirtualUri_Test_011, TestSize.Level0)
539 {
540     const string virtualUri = "file://docs/storage/Share/12.txt";
541     string realUri = MediaFileUtils::GetRealUriFromVirtualUri(virtualUri);
542     EXPECT_EQ(realUri, virtualUri);
543 }
544 
545 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_ModifyAsset_Test_001, TestSize.Level0)
546 {
547     string oldPath;
548     string newPath;
549     int32_t ret = MediaFileUtils::ModifyAsset(oldPath, newPath);
550     EXPECT_EQ(ret, E_MODIFY_DATA_FAIL);
551 
552     oldPath = "";
553     newPath = "datashare://test";
554     ret = MediaFileUtils::ModifyAsset(oldPath, newPath);
555     EXPECT_EQ(ret, E_MODIFY_DATA_FAIL);
556 
557     oldPath = "datashare://test";
558     newPath = "";
559     ret = MediaFileUtils::ModifyAsset(oldPath, newPath);
560     EXPECT_EQ(ret, E_MODIFY_DATA_FAIL);
561 
562     oldPath = "datashare://test";
563     newPath = "datashare://test/Photo";
564     ret = MediaFileUtils::ModifyAsset(oldPath, newPath);
565     EXPECT_EQ(ret, E_NO_SUCH_FILE);
566 }
567 
568 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_ModifyAsset_Test_002, TestSize.Level0)
569 {
570     string oldPath = "datashare://test/Photo";
571     string newPath = "datashare://test/Download";
572     int32_t ret = MediaFileUtils::ModifyAsset(oldPath, newPath);
573     EXPECT_EQ(ret, E_NO_SUCH_FILE);
574 }
575 
576 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CreateAsset_Test_001, TestSize.Level0)
577 {
578     string filePath;
579     int32_t ret = MediaFileUtils::CreateAsset(filePath);
580     EXPECT_EQ(ret, E_VIOLATION_PARAMETERS);
581 
582     filePath = "datashare://test";
583     MediaFileUtils::CreateAsset(filePath);
584     EXPECT_EQ(ret, E_VIOLATION_PARAMETERS);
585 }
586 
587 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsUriV10_Test_001, TestSize.Level0)
588 {
589     string mediaType = URI_TYPE_PHOTO;
590     bool ret = MediaFileUtils::IsUriV10(mediaType);
591     EXPECT_EQ(ret, true);
592 
593     mediaType = URI_TYPE_PHOTO_ALBUM;
594     ret = MediaFileUtils::IsUriV10(mediaType);
595     EXPECT_EQ(ret, true);
596 
597     mediaType = URI_TYPE_AUDIO_V10;
598     ret = MediaFileUtils::IsUriV10(mediaType);
599     EXPECT_EQ(ret, true);
600 
601     mediaType = "";
602     ret = MediaFileUtils::IsUriV10(mediaType);
603     EXPECT_EQ(ret, false);
604 }
605 
606 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_UriAppendKeyValue_Test_001, TestSize.Level0)
607 {
608     string uri;
609     string key;
610     string value;
611     MediaFileUtils::UriAppendKeyValue(uri, key, value);
612     EXPECT_EQ((uri == ""), false);
613     EXPECT_EQ((key == ""), true);
614     EXPECT_EQ((value == ""), true);
615 
616     uri = "datashare://test";
617     key = "test";
618     value = "testFile";
619     MediaFileUtils::UriAppendKeyValue(uri, key, value);
620     EXPECT_EQ((uri == ""), false);
621     EXPECT_EQ((key == ""), false);
622     EXPECT_EQ((value == ""), false);
623 }
624 
625 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_Encode_Test_001, TestSize.Level0)
626 {
627     string uri;
628     string str = MediaFileUtils::Encode(uri);
629     EXPECT_EQ((str == ""), true);
630 
631     uri = "test";
632     str = MediaFileUtils::Encode(uri);
633     EXPECT_EQ((str == ""), false);
634 
635     uri = "test/Photo";
636     str = MediaFileUtils::Encode(uri);
637     EXPECT_EQ((str == ""), false);
638 }
639 
640 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetUriByExtrConditions_Test_001, TestSize.Level0)
641 {
642     string prefix;
643     string fileId;
644     string suffix;
645     string str = MediaFileUtils::GetUriByExtrConditions(prefix, fileId, suffix);
646     EXPECT_EQ(str, "");
647 
648     prefix = "test";
649     fileId = "1234567890";
650     suffix = "file";
651     str = MediaFileUtils::GetUriByExtrConditions(prefix, fileId, suffix);
652     EXPECT_EQ(str, "test1234567890file");
653 }
654 
655 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMovingPhotoVideoPath_Test_001, TestSize.Level0)
656 {
657     string path = "/storage/cloud/files/Photo/1/IMG_test.jpg";
658     string videoPath = "/storage/cloud/files/Photo/1/IMG_test.mp4";
659     EXPECT_EQ(MediaFileUtils::GetMovingPhotoVideoPath(path), videoPath);
660 }
661 
662 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetMovingPhotoVideoPath_Test_002, TestSize.Level0)
663 {
664     string path = "/storage/cloud/files/Photo/1/invalidPath";
665     string videoPath = "";
666     EXPECT_EQ(MediaFileUtils::GetMovingPhotoVideoPath(path), videoPath);
667     EXPECT_EQ(MediaFileUtils::GetMovingPhotoVideoPath(""), videoPath);
668 }
669 
670 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoExtension_Test_001, TestSize.Level0)
671 {
672     vector<string> validExtensions = { "jpg", "jpeg", "jpe", "heif", "hif", "heic" };
673     for (const auto& extension : validExtensions) {
674         EXPECT_EQ(MediaFileUtils::CheckMovingPhotoExtension(extension), true);
675     }
676 }
677 
678 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoExtension_Test_002, TestSize.Level0)
679 {
680     vector<string> invalidExtensions = { "arw", "avif", "bm", "bmp", "cur", "dng", "gif", "heics", "heifs",
681         "ico", "nrw", "pef", "png", "raf", "raw", "rw2", "srw", "svg", "webp" };
682     for (const auto& extension : invalidExtensions) {
683         EXPECT_EQ(MediaFileUtils::CheckMovingPhotoExtension(extension), false);
684     }
685 }
686 
687 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoVideoExtension_Test_001, TestSize.Level0)
688 {
689     vector<string> validExtensions = { "m4v", "f4v", "mp4v", "mpeg4", "mp4" };
690     for (const auto& extension : validExtensions) {
691         EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoExtension(extension), true);
692     }
693 }
694 
695 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoVideoExtension_Test_002, TestSize.Level0)
696 {
697     vector<string> invalidExtensions = { "3gpp2", "3gp2", "3g2", "3gpp", "3gp", "avi", "m2ts", "mts",
698         "ts", "yt", "wrf", "mpeg", "mpeg2", "mpv2", "mp2v", "m2v", "m2t", "mpeg1", "mpv1", "mp1v", "m1v",
699         "mpg", "mov", "mkv", "webm", "h264" };
700     for (const auto& extension : invalidExtensions) {
701         EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoExtension(extension), false);
702     }
703 }
704 
705 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoImage_Test_001, TestSize.Level0)
706 {
707     string videoPath = "/storage/cloud/files/Photo/1/IMG_test_invalid.gif";
708     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoImage(videoPath), false);
709 }
710 
711 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoVideo_Test_001, TestSize.Level0)
712 {
713     string videoPath = "/storage/cloud/files/Photo/1/IMG_test_invalid.mp4";
714     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideo(videoPath), false);
715 }
716 
717 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoVideoDuration_Test_001, TestSize.Level0)
718 {
719     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-11000), false);
720     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-10000), false);
721     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-5000), false);
722     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-4000), false);
723     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-3000), false);
724     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-2500), false);
725     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-2000), false);
726     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(-1000), false);
727     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(0), false);
728     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(1000), true);
729     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(2000), true);
730     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(2500), true);
731     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(3000), true);
732     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(5000), true);
733     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(10000), true);
734     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoVideoDuration(11000), false);
735 }
736 
737 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CheckMovingPhotoEffectMode_Test_001, TestSize.Level0)
738 {
739     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoEffectMode(-10), false);
740     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoEffectMode(-1), false);
741 
742     for (int32_t i = 0; i <= 4; i++) {
743         EXPECT_EQ(MediaFileUtils::CheckMovingPhotoEffectMode(i), true);
744     }
745 
746     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoEffectMode(5), true);
747     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoEffectMode(6), false);
748     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoEffectMode(10), true);
749     EXPECT_EQ(MediaFileUtils::CheckMovingPhotoEffectMode(20), false);
750 }
751 
752 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsMediaLibraryUri_Test_001, TestSize.Level0)
753 {
754     string uri = "file://media/Photo/12/IMG_2023_001/IMG_2023.jpg";
755     EXPECT_EQ(MediaFileUtils::IsMediaLibraryUri(uri), true);
756 }
757 
758 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsMediaLibraryUri_Test_002, TestSize.Level0)
759 {
760     string uri("file://com.example.testdemo/data/storage/el2/base/haps/test.jpg");
761     uri.append(";");
762     uri.append("file://com.example.testdemo/data/storage/el2/base/haps/test.mp4");
763     EXPECT_EQ(MediaFileUtils::IsMediaLibraryUri(uri), false);
764 }
765 
766 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_IsMediaLibraryUri_Test_003, TestSize.Level0)
767 {
768     string uri = "";
769     EXPECT_EQ(MediaFileUtils::IsMediaLibraryUri(uri), false);
770 }
771 
772 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_SplitMovingPhotoUri_Test_001, TestSize.Level0)
773 {
774     string uri = "file://media/Photo/12/IMG_2023_001/IMG_2023.jpg";
775     std::vector<std::string> ret;
776     EXPECT_EQ(MediaFileUtils::SplitMovingPhotoUri(uri, ret), false);
777 }
778 
779 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_SplitMovingPhotoUri_Test_002, TestSize.Level0)
780 {
781     string uri("file://com.example.testdemo/data/storage/el2/base/haps/test.jpg");
782     uri.append(";");
783     uri.append("file://com.example.testdemo/data/storage/el2/base/haps/test.mp4");
784     std::vector<std::string> ret;
785     EXPECT_EQ(MediaFileUtils::SplitMovingPhotoUri(uri, ret), true);
786 }
787 
788 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_SplitMovingPhotoUri_Test_003, TestSize.Level0)
789 {
790     string uri = "";
791     std::vector<std::string> ret;
792     EXPECT_EQ(MediaFileUtils::SplitMovingPhotoUri(uri, ret), false);
793 }
794 
795 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GetFileSize_Test_001, TestSize.Level0)
796 {
797     bool success = true;
798     size_t size = -1;
799     string invalidPath = "/storage/cloud/files/Photo/1/IMG_test_invalid.gif";
800     success = MediaFileUtils::GetFileSize(invalidPath, size);
801     EXPECT_EQ(success, false);
802     EXPECT_EQ(size, 0);
803 }
804 
805 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_Test_001, TestSize.Level0)
806 {
807     std::string filePath;
808     std::string fileContent;
809     auto res = MediaFileUtils::ReadStrFromFile(filePath, fileContent);
810     EXPECT_EQ(res, false);
811     std::string filePath2 = "a";
812     auto res2 = MediaFileUtils::ReadStrFromFile(filePath2, fileContent);
813     EXPECT_EQ(res2, false);
814 }
815 
816 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_Test_002, TestSize.Level0)
817 {
818     string uri = "datashare:///media";
819     auto res = MediaFileUtils::GetHighlightPath(uri);
820     EXPECT_EQ(res, "/storage/cloud/files/.thumbs");
821     string uri2 = "file://media";
822     auto res2 = MediaFileUtils::GetHighlightPath(uri2);
823     EXPECT_EQ(res2, "/storage/cloud/files/.thumbs");
824     string uri3 = "";
825     auto res3 = MediaFileUtils::GetHighlightPath(uri3);
826     EXPECT_EQ(res3, "");
827 }
828 
829 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_Test_003, TestSize.Level0)
830 {
831     string filePath;
832     string mode;
833     auto res = MediaFileUtils::OpenAsset(filePath, mode);
834     EXPECT_EQ(res, -209);
835     string filePath2 = "a";
836     auto res2 = MediaFileUtils::OpenAsset(filePath2, mode);
837     EXPECT_EQ(res2, -217);
838     string filePath3 = "a";
839     string mode3 = "r";
840     auto res3 = MediaFileUtils::OpenAsset(filePath3, mode3);
841     EXPECT_EQ(res3, -209);
842     string filePath4 = "b";
843     string mode4 = "w";
844     auto res4 = MediaFileUtils::OpenAsset(filePath4, mode4);
845     EXPECT_EQ(res4, -209);
846 }
847 
848 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_Test_004, TestSize.Level0)
849 {
850     MediaType mediaType = MEDIA_TYPE_VIDEO;
851     auto res = MediaFileUtils::GetMediaTypeUri(mediaType);
852     EXPECT_EQ(res, "datashare:///media/video");
853     MediaType mediaType2 = MEDIA_TYPE_SMARTALBUM;
854     auto res2 = MediaFileUtils::GetMediaTypeUri(mediaType2);
855     EXPECT_EQ(res2, "datashare:///media/smartalbum");
856     auto res2_2 = MediaFileUtils::GetMediaTypeUriV10(mediaType2);
857     EXPECT_EQ(res2_2, "datashare:///media/smartalbum");
858     MediaType mediaType3 = MEDIA_TYPE_DEVICE;
859     auto res3 = MediaFileUtils::GetMediaTypeUri(mediaType3);
860     EXPECT_EQ(res3, "datashare:///media/device");
861     auto res3_2 = MediaFileUtils::GetMediaTypeUriV10(mediaType3);
862     EXPECT_EQ(res3_2, "datashare:///media/device");
863     MediaType mediaType4 = MEDIA_TYPE_FILE;
864     auto res4_2 = MediaFileUtils::GetMediaTypeUriV10(mediaType4);
865     EXPECT_EQ(res4_2, "datashare:///media/file");
866 }
867 
868 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_Test_005, TestSize.Level0)
869 {
870     std::string displayName = "a.mp3";
871     auto res = MediaFileUtils::GetTableNameByDisplayName(displayName);
872     EXPECT_EQ(res, "Audios");
873     std::string displayName2 = "b.mp4";
874     auto res2 = MediaFileUtils::GetTableNameByDisplayName(displayName2);
875     EXPECT_EQ(res2, "Photos");
876     std::string displayName3 = "c.jpg";
877     auto res3 = MediaFileUtils::GetTableNameByDisplayName(displayName3);
878     EXPECT_EQ(res3, "Photos");
879     std::string displayName4 = "d.txt";
880     auto res4 = MediaFileUtils::GetTableNameByDisplayName(displayName4);
881     EXPECT_EQ(res4, "");
882 }
883 
884 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CopyDirectory_Test_001, TestSize.Level0)
885 {
886     string oldDir;
887     string newDir;
888     int32_t ret = MediaFileUtils::CopyDirectory(oldDir, newDir);
889     EXPECT_EQ(ret, E_MODIFY_DATA_FAIL);
890 
891     oldDir = "";
892     newDir = "datashare://test";
893     ret = MediaFileUtils::CopyDirectory(oldDir, newDir);
894     EXPECT_EQ(ret, E_MODIFY_DATA_FAIL);
895 
896     oldDir = "datashare://test";
897     newDir = "";
898     ret = MediaFileUtils::CopyDirectory(oldDir, newDir);
899     EXPECT_EQ(ret, E_MODIFY_DATA_FAIL);
900 
901     oldDir = "datashare://test";
902     newDir = "datashare://test/Photo";
903     ret = MediaFileUtils::CopyDirectory(oldDir, newDir);
904     EXPECT_EQ(ret, E_NO_SUCH_FILE);
905 }
906 
907 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CopyDirectory_Test_002, TestSize.Level0)
908 {
909     string testPath = "/data/test/copydirectory_002";
910     string oldDir = testPath + "/copydirectory_002_srcdir";
911     string newDir = testPath + "/copydirectory_002_dstdir";
912     EXPECT_EQ(MediaFileUtils::CreateFile(oldDir), true);
913     int32_t ret = MediaFileUtils::CopyDirectory(oldDir, newDir);
914     EXPECT_EQ(ret, E_FAIL);
915 }
916 
917 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CopyDirectory_Test_003, TestSize.Level0)
918 {
919     string testPath = "/data/test/copydirectory_003";
920     string oldDir = testPath + "/copydirectory_003_srcdir";
921     string newDir = testPath + "/copydirectory_003_dstdir";
922     EXPECT_EQ(MediaFileUtils::CreateDirectory(oldDir), true);
923     EXPECT_EQ(MediaFileUtils::CreateDirectory(newDir), true);
924     int32_t ret = MediaFileUtils::CopyDirectory(oldDir, newDir);
925     EXPECT_EQ(ret, E_FILE_EXIST);
926 }
927 
928 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_CopyDirectory_Test_004, TestSize.Level0)
929 {
930     string testPath = "/data/test/copydirectory_004";
931     string oldDir = testPath + "/copydirectory_004_srcdir";
932     string newDir = testPath + "/copydirectory_004_dstdir";
933     string subdirectory = oldDir + "/copydirectory_subdirectory";
934     string subfile = oldDir + "/copydirectory_subfile";
935     EXPECT_EQ(MediaFileUtils::CreateDirectory(oldDir), true);
936     EXPECT_EQ(MediaFileUtils::CreateDirectory(subdirectory), true);
937     EXPECT_EQ(MediaFileUtils::CreateFile(subfile), true);
938     int32_t ret = MediaFileUtils::CopyDirectory(oldDir, newDir);
939     EXPECT_EQ(ret, E_OK);
940 }
941 
942 HWTEST_F(MediaLibraryHelperUnitTest, MediaFileUtils_GenerateKvStoreKey_Test_001, TestSize.Level0)
943 {
944     std::string fileId;
945     std::string datekey;
946     std::string key;
947     fileId = "";
948     auto res = MediaFileUtils::GenerateKvStoreKey(fileId, datekey, key);
949     EXPECT_EQ(res, false);
950 
951     fileId = "a";
952     datekey = "";
953     res = MediaFileUtils::GenerateKvStoreKey(fileId, datekey, key);
954     EXPECT_EQ(res, false);
955 
956     fileId = "0000000000a";
957     datekey = "a";
958     res = MediaFileUtils::GenerateKvStoreKey(fileId, datekey, key);
959     EXPECT_EQ(res, false);
960 
961     fileId = "0000000000";
962     datekey = "0000000000000a";
963     res = MediaFileUtils::GenerateKvStoreKey(fileId, datekey, key);
964     EXPECT_EQ(res, false);
965 
966     fileId = "0000000000";
967     datekey = "0000000000000";
968     res = MediaFileUtils::GenerateKvStoreKey(fileId, datekey, key);
969     EXPECT_EQ(res, true);
970 }
971 } // namespace Media
972 } // namespace OHOS
973