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 #define MLOG_TAG "FileExtUnitTest"
16
17 #include "medialibrary_fileext_test.h"
18
19 #include <regex>
20
21 #include "file_asset.h"
22 #include "get_self_permissions.h"
23 #include "js_runtime.h"
24 #include "medialibrary_command.h"
25 #include "media_file_ext_ability.h"
26 #include "media_file_extention_utils.h"
27 #include "media_log.h"
28 #include "medialibrary_client_errno.h"
29 #include "medialibrary_db_const.h"
30 #include "medialibrary_errno.h"
31 #include "medialibrary_photo_operations.h"
32 #include "medialibrary_unittest_utils.h"
33 #include "scanner_utils.h"
34 #include "securec.h"
35 #include "uri.h"
36 #include "values_bucket.h"
37
38 using namespace std;
39 using namespace OHOS;
40 using namespace testing::ext;
41 using namespace FileAccessFwk;
42
43 namespace OHOS {
44 namespace Media {
45 namespace {
46 shared_ptr<FileAsset> g_pictures = nullptr;
47 shared_ptr<FileAsset> g_camera = nullptr;
48 shared_ptr<FileAsset> g_videos = nullptr;
49 shared_ptr<FileAsset> g_audios = nullptr;
50 shared_ptr<FileAsset> g_documents = nullptr;
51 shared_ptr<FileAsset> g_download = nullptr;
52 shared_ptr<MediaFileExtAbility> mediaFileExtAbility = nullptr;
53 const string DISTRIBUTED_PREFIX =
54 "datashare://1d3cb099659d53b3ee15faaab3c00a8ff983382ebc8b01aabde039ed084e167b/media/";
55 const string COMMON_PREFIX = "datashare:///media/";
56 const string ROOT_URI = "root";
57 const string COMMON_URI = "file/1";
58 const string INVALID_URI = "file/test";
59 const string INVALID_FILE_NAME = "te/st.jpg";
60 const string INVALID_DIR_NAME = "te/st";
61
62 // Unordered set contains list supported audio formats
63 const std::unordered_set<std::string> SUPPORTED_AUDIO_FORMATS_SET {
64 AUDIO_CONTAINER_TYPE_AAC,
65 AUDIO_CONTAINER_TYPE_MP3,
66 AUDIO_CONTAINER_TYPE_FLAC,
67 AUDIO_CONTAINER_TYPE_WAV,
68 AUDIO_CONTAINER_TYPE_OGG,
69 AUDIO_CONTAINER_TYPE_M4A
70 };
71
72 // Unordered set contains list supported video formats
73 const std::unordered_set<std::string> SUPPORTED_VIDEO_FORMATS_SET {
74 VIDEO_CONTAINER_TYPE_MP4,
75 VIDEO_CONTAINER_TYPE_3GP,
76 VIDEO_CONTAINER_TYPE_MPG,
77 VIDEO_CONTAINER_TYPE_MOV,
78 VIDEO_CONTAINER_TYPE_WEBM,
79 VIDEO_CONTAINER_TYPE_MKV,
80 VIDEO_CONTAINER_TYPE_H264,
81 VIDEO_CONTAINER_TYPE_MPEG,
82 VIDEO_CONTAINER_TYPE_TS,
83 VIDEO_CONTAINER_TYPE_M4V,
84 VIDEO_CONTAINER_TYPE_3G2
85 };
86
87 // Unordered set contains list supported image formats
88 const std::unordered_set<std::string> SUPPORTED_IMAGE_FORMATS_SET {
89 IMAGE_CONTAINER_TYPE_BMP,
90 IMAGE_CONTAINER_TYPE_BM,
91 IMAGE_CONTAINER_TYPE_GIF,
92 IMAGE_CONTAINER_TYPE_JPG,
93 IMAGE_CONTAINER_TYPE_JPEG,
94 IMAGE_CONTAINER_TYPE_JPE,
95 IMAGE_CONTAINER_TYPE_PNG,
96 IMAGE_CONTAINER_TYPE_WEBP,
97 IMAGE_CONTAINER_TYPE_RAW,
98 IMAGE_CONTAINER_TYPE_SVG,
99 IMAGE_CONTAINER_TYPE_HEIF
100 };
101 } // namespace
102
103 class ArkJsRuntime : public AbilityRuntime::JsRuntime {
104 public:
ArkJsRuntime()105 ArkJsRuntime() {};
106
~ArkJsRuntime()107 ~ArkJsRuntime() {};
108
StartDebugMode(const DebugOption debugOption)109 void StartDebugMode(const DebugOption debugOption) {};
FinishPreload()110 void FinishPreload() {};
LoadRepairPatch(const string & patchFile,const string & baseFile)111 bool LoadRepairPatch(const string& patchFile, const string& baseFile)
112 {
113 return true;
114 };
NotifyHotReloadPage()115 bool NotifyHotReloadPage()
116 {
117 return true;
118 };
UnLoadRepairPatch(const string & patchFile)119 bool UnLoadRepairPatch(const string& patchFile)
120 {
121 return true;
122 };
RunScript(const string & path,const string & hapPath,bool useCommonChunk=false)123 bool RunScript(const string& path, const string& hapPath, bool useCommonChunk = false)
124 {
125 return true;
126 };
127 };
128
SetUpTestCase(void)129 void MediaLibraryFileExtUnitTest::SetUpTestCase(void)
130 {
131 MediaLibraryUnitTestUtils::Init();
132
133 ArkJsRuntime runtime;
134 mediaFileExtAbility = make_shared<MediaFileExtAbility>(runtime);
135
136 vector<string> perms = { "ohos.permission.MEDIA_LOCATION" };
137 uint64_t tokenId = 0;
138 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryFileExtUnitTest", perms, tokenId);
139 ASSERT_TRUE(tokenId != 0);
140 }
141
TearDownTestCase(void)142 void MediaLibraryFileExtUnitTest::TearDownTestCase(void)
143 {
144 MEDIA_ERR_LOG("TearDownTestCase start");
145 if (mediaFileExtAbility != nullptr) {
146 mediaFileExtAbility = nullptr;
147 }
148 MEDIA_INFO_LOG("TearDownTestCase end");
149 }
150
SetUp()151 void MediaLibraryFileExtUnitTest::SetUp()
152 {
153 MediaLibraryUnitTestUtils::CleanTestFiles();
154 MediaLibraryUnitTestUtils::InitRootDirs();
155 g_pictures = MediaLibraryUnitTestUtils::GetRootAsset(TEST_PICTURES);
156 g_camera = MediaLibraryUnitTestUtils::GetRootAsset(TEST_CAMERA);
157 g_videos = MediaLibraryUnitTestUtils::GetRootAsset(TEST_VIDEOS);
158 g_audios = MediaLibraryUnitTestUtils::GetRootAsset(TEST_AUDIOS);
159 g_documents = MediaLibraryUnitTestUtils::GetRootAsset(TEST_DOCUMENTS);
160 g_download = MediaLibraryUnitTestUtils::GetRootAsset(TEST_DOWNLOAD);
161 }
162
TearDown(void)163 void MediaLibraryFileExtUnitTest::TearDown(void) {}
164
ReturnUri(string prefixType,string uriType,string subUri="")165 string ReturnUri(string prefixType, string uriType, string subUri = "")
166 {
167 return (prefixType + uriType + subUri);
168 }
169
170 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_OpenFile_test_001, TestSize.Level0)
171 {
172 if (!MediaLibraryUnitTestUtils::IsValid()) {
173 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
174 exit(1);
175 }
176 Uri fileAsset("");
177 shared_ptr<FileAsset> albumAsset = nullptr;
178 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("CreateFile_test_001", g_documents, albumAsset), true);
179 Uri parentUri(albumAsset->GetUri());
180 ASSERT_EQ(mediaFileExtAbility->CreateFile(parentUri, "OpenFile_test_001.jpg", fileAsset), E_SUCCESS);
181 int fd = -1;
182 auto ret = mediaFileExtAbility->OpenFile(fileAsset, O_RDWR, fd);
183 MEDIA_DEBUG_LOG("medialib_OpenFile_test_001 fileAsset: %{public}s, fd: %{public}d",
184 fileAsset.ToString().c_str(), fd);
185 EXPECT_EQ(ret == E_SUCCESS, true);
186 if (ret == E_SUCCESS) {
187 char str[] = "Hello World!";
188 int size_written = -1, size_read = -1, strLen = strlen(str);
189 size_written = write(fd, str, strLen);
190 if (size_written == -1) {
191 MEDIA_DEBUG_LOG("medialib_OpenFile_test_001 write errno: %{public}d, errmsg: %{public}s",
192 errno, strerror(errno));
193 }
194 EXPECT_EQ(size_written, strLen);
195 memset_s(str, sizeof(str), 0, sizeof(str));
196 lseek(fd, 0, SEEK_SET);
197 size_read = read(fd, str, strLen);
198 if (size_read == -1) {
199 MEDIA_DEBUG_LOG("medialib_OpenFile_test_001 read errno: %{public}d, errmsg: %{public}s",
200 errno, strerror(errno));
201 }
202 EXPECT_EQ(size_read, strLen);
203 MEDIA_DEBUG_LOG("medialib_OpenFile_test_001 size_written: %{public}d, size_read: %{public}d",
204 size_written, size_read);
205 } else {
206 MEDIA_DEBUG_LOG("medialib_OpenFile_test_001 OpenFile errno: %{public}d, errmsg: %{public}s",
207 errno, strerror(errno));
208 }
209 }
210
211 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_OpenFile_test_002, TestSize.Level0)
212 {
213 if (!MediaLibraryUnitTestUtils::IsValid()) {
214 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
215 exit(1);
216 }
217 Uri uri(g_documents->GetUri());
218 MEDIA_DEBUG_LOG("medialib_OpenFile_test_002 uri %{public}s", uri.ToString().c_str());
219 int fd = -1;
220 auto ret = mediaFileExtAbility->OpenFile(uri, O_RDWR, fd);
221 if (ret == JS_INNER_FAIL) {
222 MEDIA_DEBUG_LOG("medialib_OpenFile_test_002 OpenFile errno: %{public}d, errmsg: %{public}s",
223 errno, strerror(errno));
224 }
225 EXPECT_EQ(ret, JS_INNER_FAIL);
226 }
227
228 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_CreateFile_test_001, TestSize.Level0)
229 {
230 MEDIA_DEBUG_LOG("medialib_CreateFile_test_001::Start");
231 if (!MediaLibraryUnitTestUtils::IsValid()) {
232 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
233 exit(1);
234 }
235 shared_ptr<FileAsset> albumAsset = nullptr;
236 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("CreateFile_test_001", g_documents, albumAsset), true);
237 Uri parentUri(albumAsset->GetUri());
238 Uri newUri("");
239 string displayName = "CreateFile001.jpg";
240 string filePath = albumAsset->GetPath() + "/" + displayName;
241 MEDIA_DEBUG_LOG("parentUri: %{private}s, displayName: %{public}s, filePath: %{private}s",
242 parentUri.ToString().c_str(), displayName.c_str(), filePath.c_str());
243 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(filePath), false);
244 int32_t ret = mediaFileExtAbility->CreateFile(parentUri, displayName, newUri);
245 EXPECT_EQ(ret, E_SUCCESS);
246 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(filePath), true);
247 MEDIA_DEBUG_LOG("ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
248 MEDIA_DEBUG_LOG("medialib_CreateFile_test_001::End");
249 }
250
251 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_CreateFile_test_002, TestSize.Level0)
252 {
253 MEDIA_DEBUG_LOG("medialib_CreateFile_test_002::Start");
254 if (!MediaLibraryUnitTestUtils::IsValid()) {
255 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
256 exit(1);
257 }
258 shared_ptr<FileAsset> albumAsset = nullptr;
259 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("CreateFile_test_002", g_documents, albumAsset), true);
260 Uri parentUri(albumAsset->GetUri());
261 Uri newUri("");
262 string displayName = INVALID_FILE_NAME;
263 MEDIA_DEBUG_LOG("parentUri: %{public}s, displayName: %{public}s",
264 parentUri.ToString().c_str(), displayName.c_str());
265 int32_t ret = mediaFileExtAbility->CreateFile(parentUri, displayName, newUri);
266 EXPECT_EQ(ret, JS_E_DISPLAYNAME);
267 MEDIA_DEBUG_LOG("ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
268 MEDIA_DEBUG_LOG("medialib_CreateFile_test_002::End");
269 }
270
271 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_CreateFile_test_003, TestSize.Level0)
272 {
273 MEDIA_DEBUG_LOG("medialib_CreateFile_test_003::Start");
274 if (!MediaLibraryUnitTestUtils::IsValid()) {
275 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
276 exit(1);
277 }
278 Uri parentUri(ReturnUri(COMMON_PREFIX, INVALID_URI));
279 Uri newUri("");
280 string displayName = "CreateFile001.jpg";
281 MEDIA_DEBUG_LOG("parentUri: %{public}s, displayName: %{public}s",
282 parentUri.ToString().c_str(), displayName.c_str());
283 int32_t ret = mediaFileExtAbility->CreateFile(parentUri, displayName, newUri);
284 EXPECT_EQ(ret, JS_E_URI);
285 MEDIA_DEBUG_LOG("ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
286 MEDIA_DEBUG_LOG("medialib_CreateFile_test_003::End");
287 }
288
289 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_CreateFile_test_004, TestSize.Level0)
290 {
291 MEDIA_DEBUG_LOG("medialib_CreateFile_test_004::Start");
292 if (!MediaLibraryUnitTestUtils::IsValid()) {
293 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
294 exit(1);
295 }
296 Uri parentUri(ReturnUri(DISTRIBUTED_PREFIX, COMMON_URI));
297 Uri newUri("");
298 string displayName = "CreateFile001.jpg";
299 MEDIA_DEBUG_LOG("parentUri: %{public}s, displayName: %{public}s",
300 parentUri.ToString().c_str(), displayName.c_str());
301 int32_t ret = mediaFileExtAbility->CreateFile(parentUri, displayName, newUri);
302 EXPECT_EQ(ret, JS_E_URI);
303 MEDIA_DEBUG_LOG("ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
304 MEDIA_DEBUG_LOG("medialib_CreateFile_test_004::End");
305 }
306
307 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_CreateFile_test_005, TestSize.Level0)
308 {
309 MEDIA_DEBUG_LOG("medialib_CreateFile_test_005::Start");
310 if (!MediaLibraryUnitTestUtils::IsValid()) {
311 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
312 exit(1);
313 }
314 shared_ptr<FileAsset> albumAsset = nullptr;
315 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("CreateFile_test_005", g_documents, albumAsset), true);
316 shared_ptr<FileAsset> fileAsset = nullptr;
317 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("CreateFile_test_005.jpg", albumAsset, fileAsset), true);
318 Uri parentUri(albumAsset->GetUri());
319 Uri newUri("");
320 string displayName = "CreateFile_test_005.jpg";
321 MEDIA_DEBUG_LOG("parentUri: %{public}s, displayName: %{public}s",
322 parentUri.ToString().c_str(), displayName.c_str());
323 int32_t ret = mediaFileExtAbility->CreateFile(parentUri, displayName, newUri);
324 EXPECT_EQ(ret, JS_ERR_FILE_EXIST);
325 MEDIA_DEBUG_LOG("ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
326 MEDIA_DEBUG_LOG("medialib_CreateFile_test_005::End");
327 }
328
329 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_001, TestSize.Level0)
330 {
331 if (!MediaLibraryUnitTestUtils::IsValid()) {
332 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
333 exit(1);
334 }
335 auto audioAsset = MediaLibraryUnitTestUtils::GetRootAsset(TEST_AUDIOS);
336 MEDIA_DEBUG_LOG("medialib_Mkdir_test_001 delete audios start, uri: %{public}s", audioAsset->GetUri().c_str());
337 ASSERT_EQ(MediaLibraryUnitTestUtils::DeleteDir(audioAsset->GetPath(), to_string(audioAsset->GetId())), true);
338 Uri parentUri(ReturnUri(COMMON_PREFIX, ROOT_URI, MEDIALIBRARY_TYPE_FILE_URI));
339 string displayName = "Documents";
340 string dirPath = ROOT_MEDIA_DIR + displayName;
341 MEDIA_DEBUG_LOG("medialib_Mkdir_test_001 parentUri: %{public}s, displayName: %{public}s",
342 parentUri.ToString().c_str(), displayName.c_str());
343 Uri newUri("");
344 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
345 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(dirPath), true);
346 MEDIA_DEBUG_LOG("medialib_Mkdir_test_001 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
347 }
348
349 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_002, TestSize.Level0)
350 {
351 if (!MediaLibraryUnitTestUtils::IsValid()) {
352 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
353 exit(1);
354 }
355 Uri parentUri(ReturnUri(DISTRIBUTED_PREFIX, ROOT_URI, MEDIALIBRARY_TYPE_FILE_URI));
356 string displayName = "Mkdir_test_002";
357 MEDIA_DEBUG_LOG("medialib_Mkdir_test_002 parentUri: %{public}s, displayName: %{public}s",
358 parentUri.ToString().c_str(), displayName.c_str());
359 Uri newUri("");
360 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
361 EXPECT_EQ(ret, JS_E_URI);
362 MEDIA_DEBUG_LOG("medialib_Mkdir_test_002 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
363 }
364
365 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_003, TestSize.Level0)
366 {
367 if (!MediaLibraryUnitTestUtils::IsValid()) {
368 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
369 exit(1);
370 }
371 Uri parentUri(ReturnUri(COMMON_PREFIX, ROOT_URI, MEDIALIBRARY_TYPE_FILE_URI));
372 string displayName = "Mkdir_test_003";
373 MEDIA_DEBUG_LOG("medialib_Mkdir_test_003 parentUri: %{public}s, displayName: %{public}s",
374 parentUri.ToString().c_str(), displayName.c_str());
375 Uri newUri("");
376 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
377 EXPECT_EQ(ret, JS_E_DISPLAYNAME);
378 MEDIA_DEBUG_LOG("medialib_Mkdir_test_003 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
379 }
380
381 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_004, TestSize.Level0)
382 {
383 if (!MediaLibraryUnitTestUtils::IsValid()) {
384 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
385 exit(1);
386 }
387 Uri parentUri(g_download->GetUri());
388 string displayName = "Mkdir_test_004";
389 string dirPath = g_download->GetPath() + "/" + displayName;
390 MEDIA_DEBUG_LOG("medialib_Mkdir_test_004 parentUri: %{public}s, displayName: %{public}s",
391 parentUri.ToString().c_str(), displayName.c_str());
392 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(dirPath), false);
393 Uri newUri("");
394 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
395 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(dirPath), true);
396 MEDIA_DEBUG_LOG("medialib_Mkdir_test_004 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
397 }
398
399 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_005, TestSize.Level0)
400 {
401 if (!MediaLibraryUnitTestUtils::IsValid()) {
402 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
403 exit(1);
404 }
405 Uri parentUri(ReturnUri(COMMON_PREFIX, INVALID_URI));
406 string displayName = "Mkdir_test_005";
407 MEDIA_DEBUG_LOG("medialib_Mkdir_test_005 parentUri: %{public}s, displayName: %{public}s",
408 parentUri.ToString().c_str(), displayName.c_str());
409 Uri newUri("");
410 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
411 EXPECT_EQ(ret, JS_E_URI);
412 MEDIA_DEBUG_LOG("medialib_Mkdir_test_005 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
413 }
414
415 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_006, TestSize.Level0)
416 {
417 if (!MediaLibraryUnitTestUtils::IsValid()) {
418 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
419 exit(1);
420 }
421 Uri parentUri(ReturnUri(DISTRIBUTED_PREFIX, COMMON_URI));
422 string displayName = "Mkdir_test_006";
423 MEDIA_DEBUG_LOG("medialib_Mkdir_test_006 parentUri: %{public}s, displayName: %{public}s",
424 parentUri.ToString().c_str(), displayName.c_str());
425 Uri newUri("");
426 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
427 EXPECT_EQ(ret, JS_E_URI);
428 MEDIA_DEBUG_LOG("medialib_Mkdir_test_006 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
429 }
430
431 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_007, TestSize.Level0)
432 {
433 if (!MediaLibraryUnitTestUtils::IsValid()) {
434 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
435 exit(1);
436 }
437 Uri parentUri(g_download->GetUri());
438 string displayName = INVALID_DIR_NAME;
439 MEDIA_DEBUG_LOG("medialib_Mkdir_test_007 parentUri: %{public}s, displayName: %{public}s",
440 parentUri.ToString().c_str(), displayName.c_str());
441 Uri newUri("");
442 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
443 EXPECT_EQ(ret, JS_E_DISPLAYNAME);
444 MEDIA_DEBUG_LOG("medialib_Mkdir_test_007 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
445 }
446
447 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_008, TestSize.Level0)
448 {
449 if (!MediaLibraryUnitTestUtils::IsValid()) {
450 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
451 exit(1);
452 }
453 shared_ptr<FileAsset> albumAsset = nullptr;
454 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Mkdir_test_008", g_download, albumAsset), true);
455 Uri parentUri(g_download->GetUri());
456 string displayName = "Mkdir_test_008";
457 MEDIA_DEBUG_LOG("medialib_Mkdir_test_008 parentUri: %{public}s, displayName: %{public}s",
458 parentUri.ToString().c_str(), displayName.c_str());
459 Uri newUri("");
460 int32_t ret = mediaFileExtAbility->Mkdir(parentUri, displayName, newUri);
461 EXPECT_EQ(ret, JS_ERR_FILE_EXIST);
462 MEDIA_DEBUG_LOG("medialib_Mkdir_test_008 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
463 }
464
465 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Mkdir_test_009, TestSize.Level0)
466 {
467 if (!MediaLibraryUnitTestUtils::IsValid()) {
468 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
469 exit(1);
470 }
471 Uri parentUri(g_camera->GetUri());
472 string displayName = "test";
473 Uri newUri("");
474 int32_t ret = MediaFileExtentionUtils::Mkdir(parentUri, displayName, newUri);
475 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
476 Uri parentUriTest(g_videos->GetUri());
477 ret = MediaFileExtentionUtils::Mkdir(parentUriTest, displayName, newUri);
478 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
479 Uri parentUriOne(g_pictures->GetUri());
480 ret = MediaFileExtentionUtils::Mkdir(parentUriOne, displayName, newUri);
481 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
482 Uri parentUriTwo(g_audios->GetUri());
483 ret = MediaFileExtentionUtils::Mkdir(parentUriTwo, displayName, newUri);
484 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
485 Uri parentUriThree(g_documents->GetUri());
486 ret = MediaFileExtentionUtils::Mkdir(parentUriThree, displayName, newUri);
487 EXPECT_GT(ret, E_SUCCESS);
488 Uri parentUriFour(g_download->GetUri());
489 ret = MediaFileExtentionUtils::Mkdir(parentUriFour, displayName, newUri);
490 EXPECT_GT(ret, E_SUCCESS);
491 }
492
493 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Delete_test_001, TestSize.Level0)
494 {
495 if (!MediaLibraryUnitTestUtils::IsValid()) {
496 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
497 exit(1);
498 }
499 shared_ptr<FileAsset> albumAsset = nullptr;
500 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Delete_test_001", g_documents, albumAsset), true);
501 shared_ptr<FileAsset> fileAsset = nullptr;
502 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Delete_test_001.jpg", albumAsset, fileAsset), true);
503 Uri sourceUri(fileAsset->GetUri());
504 MEDIA_DEBUG_LOG("medialib_Delete_test_001 sourceUri %{public}s", sourceUri.ToString().c_str());
505 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(fileAsset->GetPath()), true);
506 int32_t ret = mediaFileExtAbility->Delete(sourceUri);
507 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(fileAsset->GetPath()), false);
508 MEDIA_DEBUG_LOG("medialib_Delete_test_001 ret: %{public}d", ret);
509 }
510
511 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Delete_test_002, TestSize.Level0)
512 {
513 if (!MediaLibraryUnitTestUtils::IsValid()) {
514 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
515 exit(1);
516 }
517 Uri sourceUri(ReturnUri(DISTRIBUTED_PREFIX, COMMON_URI));
518 MEDIA_DEBUG_LOG("medialib_Delete_test_002 sourceUri %{public}s", sourceUri.ToString().c_str());
519 int32_t ret = mediaFileExtAbility->Delete(sourceUri);
520 EXPECT_EQ(ret, JS_E_URI);
521 MEDIA_DEBUG_LOG("medialib_Delete_test_002 ret: %{public}d", ret);
522 }
523
524 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Delete_test_003, TestSize.Level0)
525 {
526 if (!MediaLibraryUnitTestUtils::IsValid()) {
527 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
528 exit(1);
529 }
530 shared_ptr<FileAsset> albumAsset = nullptr;
531 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Delete_test_001", g_pictures, albumAsset), true);
532 shared_ptr<FileAsset> fileAsset = nullptr;
533 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Delete_test_001.jpg", albumAsset, fileAsset), true);
534 Uri sourceUri(fileAsset->GetUri());
535 int32_t ret = MediaFileExtentionUtils::Delete(sourceUri);
536 EXPECT_EQ(ret, E_URI_INVALID);
537 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Delete_test_001.jpg", g_documents, fileAsset), true);
538 Uri sourceUriOne(fileAsset->GetUri());
539 ret = MediaFileExtentionUtils::Delete(sourceUriOne);
540 EXPECT_GT(ret, E_SUCCESS);
541 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Delete_test_001.jpg", g_download, fileAsset), true);
542 Uri sourceUriTwo(fileAsset->GetUri());
543 ret = MediaFileExtentionUtils::Delete(sourceUriTwo);
544 EXPECT_GT(ret, E_SUCCESS);
545 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Delete_test_001.jpg", g_camera, fileAsset), true);
546 Uri sourceUriThree(fileAsset->GetUri());
547 ret = MediaFileExtentionUtils::Delete(sourceUriThree);
548 EXPECT_EQ(ret, E_URI_INVALID);
549 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Delete_test_001.mp4", g_videos, fileAsset), true);
550 Uri sourceUriFour(fileAsset->GetUri());
551 ret = MediaFileExtentionUtils::Delete(sourceUriFour);
552 EXPECT_EQ(ret, E_URI_INVALID);
553 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Delete_test_001.mp3", g_audios, fileAsset), true);
554 Uri sourceUriFive(fileAsset->GetUri());
555 ret = MediaFileExtentionUtils::Delete(sourceUriFive);
556 EXPECT_EQ(ret, E_URI_INVALID);
557 }
558
559 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_001, TestSize.Level0)
560 {
561 if (!MediaLibraryUnitTestUtils::IsValid()) {
562 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
563 exit(1);
564 }
565 shared_ptr<FileAsset> srcAlbumAsset = nullptr;
566 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_001", g_download, srcAlbumAsset), true);
567 shared_ptr<FileAsset> destAlbumAsset = nullptr;
568 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_001_dst", g_download, destAlbumAsset), true);
569 shared_ptr<FileAsset> fileAsset = nullptr;
570 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_001.jpg", srcAlbumAsset, fileAsset), true);
571 Uri sourceUri(fileAsset->GetUri());
572 Uri targetUri(destAlbumAsset->GetUri());
573 Uri newUri("");
574 MEDIA_DEBUG_LOG("medialib_Move_test_001 sourceUri: %{public}s, targetUri: %{public}s",
575 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
576 string srcPath = fileAsset->GetPath();
577 string displayName = fileAsset->GetDisplayName();
578 string targetPath = destAlbumAsset->GetPath() + "/" + displayName;
579 MEDIA_DEBUG_LOG("medialib_Move_test_001 srcPath: %{private}s, targetPath: %{private}s",
580 srcPath.c_str(), targetPath.c_str());
581 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(srcPath), true);
582 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(targetPath), false);
583 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
584 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(srcPath), false);
585 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(targetPath), true);
586 MEDIA_DEBUG_LOG("medialib_Move_test_001 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
587 }
588
589 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_002, TestSize.Level0)
590 {
591 if (!MediaLibraryUnitTestUtils::IsValid()) {
592 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
593 exit(1);
594 }
595 shared_ptr<FileAsset> srcAlbumAsset = nullptr;
596 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002", g_documents, srcAlbumAsset), true);
597 shared_ptr<FileAsset> fileAsset = nullptr;
598 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_002.jpg", srcAlbumAsset, fileAsset), true);
599 shared_ptr<FileAsset> destAlbumAsset = nullptr;
600 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002_dest", g_download, destAlbumAsset), true);
601 Uri sourceUri(srcAlbumAsset->GetUri());
602 Uri targetUri(destAlbumAsset->GetUri());
603 Uri newUri("");
604 MEDIA_DEBUG_LOG("medialib_Move_test_002 sourceUri: %{public}s, targetUri: %{public}s",
605 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
606 string srcPath = srcAlbumAsset->GetPath();
607 string displayName = srcAlbumAsset->GetDisplayName();
608 string targetPath = destAlbumAsset->GetPath() + "/" + displayName;
609 MEDIA_DEBUG_LOG("medialib_Move_test_002 srcPath: %{private}s, targetPath: %{private}s",
610 srcPath.c_str(), targetPath.c_str());
611 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(srcPath), true);
612 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(targetPath), false);
613 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
614 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(srcPath), false);
615 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(targetPath), true);
616 MEDIA_DEBUG_LOG("medialib_Move_test_002 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
617 }
618
619 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_003, TestSize.Level0)
620 {
621 if (!MediaLibraryUnitTestUtils::IsValid()) {
622 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
623 exit(1);
624 }
625 shared_ptr<FileAsset> fileAsset = nullptr;
626 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_003.jpg", g_download, fileAsset), true);
627 Uri sourceUri(fileAsset->GetUri());
628 Uri targetUri(ReturnUri(COMMON_PREFIX, INVALID_URI));
629 Uri newUri("");
630 MEDIA_DEBUG_LOG("medialib_Move_test_003 sourceUri: %{public}s, targetUri: %{public}s",
631 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
632 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
633 EXPECT_EQ(ret, JS_E_URI);
634 MEDIA_DEBUG_LOG("medialib_Move_test_003 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
635 }
636
637 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_004, TestSize.Level0)
638 {
639 if (!MediaLibraryUnitTestUtils::IsValid()) {
640 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
641 exit(1);
642 }
643 shared_ptr<FileAsset> fileAsset = nullptr;
644 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_004.jpg", g_download, fileAsset), true);
645 Uri sourceUri(fileAsset->GetUri());
646 Uri targetUri(ReturnUri(DISTRIBUTED_PREFIX, COMMON_URI));
647 Uri newUri("");
648 MEDIA_DEBUG_LOG("medialib_Move_test_004 sourceUri: %{public}s, targetUri: %{public}s",
649 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
650 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
651 EXPECT_EQ(ret, JS_E_URI);
652 MEDIA_DEBUG_LOG("medialib_Move_test_004 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
653 }
654
655 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_005, TestSize.Level0)
656 {
657 if (!MediaLibraryUnitTestUtils::IsValid()) {
658 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
659 exit(1);
660 }
661 shared_ptr<FileAsset> albumAsset = nullptr;
662 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_005_dest", g_download, albumAsset), true);
663 Uri sourceUri(ReturnUri(COMMON_PREFIX, INVALID_URI));
664 Uri targetUri(albumAsset->GetUri());
665 Uri newUri("");
666 MEDIA_DEBUG_LOG("medialib_Move_test_005 sourceUri: %{public}s, targetUri: %{public}s",
667 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
668 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
669 EXPECT_EQ(ret, JS_E_URI);
670 MEDIA_DEBUG_LOG("medialib_Move_test_005 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
671 }
672
673 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_006, TestSize.Level0)
674 {
675 if (!MediaLibraryUnitTestUtils::IsValid()) {
676 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
677 exit(1);
678 }
679 shared_ptr<FileAsset> albumAsset = nullptr;
680 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_006_dest", g_download, albumAsset), true);
681 Uri sourceUri(ReturnUri(DISTRIBUTED_PREFIX, COMMON_URI));
682 Uri targetUri(albumAsset->GetUri());
683 Uri newUri("");
684 MEDIA_DEBUG_LOG("medialib_Move_test_006 sourceUri: %{public}s, targetUri: %{public}s",
685 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
686 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
687 EXPECT_EQ(ret, JS_E_URI);
688 MEDIA_DEBUG_LOG("medialib_Move_test_006 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
689 }
690
691 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_007, TestSize.Level0)
692 {
693 if (!MediaLibraryUnitTestUtils::IsValid()) {
694 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
695 exit(1);
696 }
697 shared_ptr<FileAsset> fileAsset = nullptr;
698 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_007.jpg", g_download, fileAsset), true);
699 shared_ptr<FileAsset> albumAsset = nullptr;
700 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_007_dest", g_download, albumAsset), true);
701 shared_ptr<FileAsset> tempFileAsset = nullptr;
702 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_007.jpg", albumAsset, tempFileAsset), true);
703 Uri sourceUri(fileAsset->GetUri());
704 Uri targetUri(albumAsset->GetUri());
705 Uri newUri("");
706 MEDIA_DEBUG_LOG("medialib_Move_test_007 sourceUri: %{public}s, targetUri: %{public}s",
707 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
708 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
709 EXPECT_EQ(ret, JS_ERR_FILE_EXIST);
710 MEDIA_DEBUG_LOG("medialib_Move_test_007 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
711 }
712
713 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_008, TestSize.Level0)
714 {
715 if (!MediaLibraryUnitTestUtils::IsValid()) {
716 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
717 exit(1);
718 }
719 if (g_documents == nullptr) {
720 MEDIA_ERR_LOG("g_documents == nullptr");
721 EXPECT_EQ(true, false);
722 return;
723 }
724 shared_ptr<FileAsset> fileAsset = nullptr;
725 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_008.jpg", g_download, fileAsset), true);
726 Uri sourceUri(fileAsset->GetUri());
727 Uri targetUri(g_documents->GetUri());
728 MEDIA_DEBUG_LOG("medialib_Move_test_008 sourceUri: %{public}s, targetUri: %{public}s",
729 sourceUri.ToString().c_str(), targetUri.ToString().c_str());
730 Uri newUri("");
731 string srcPath = fileAsset->GetPath();
732 string displayName = fileAsset->GetDisplayName();
733 string targetPath = g_documents->GetPath() + "/" + displayName;
734 MEDIA_DEBUG_LOG("medialib_Move_test_008 srcPath: %{private}s, targetPath: %{private}s",
735 srcPath.c_str(), targetPath.c_str());
736 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(srcPath), true);
737 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(targetPath), false);
738 int32_t ret = mediaFileExtAbility->Move(sourceUri, targetUri, newUri);
739 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(srcPath), false);
740 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(targetPath), true);
741 MEDIA_DEBUG_LOG("medialib_Move_test_008 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
742 }
743
744 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Move_test_009, TestSize.Level0)
745 {
746 if (!MediaLibraryUnitTestUtils::IsValid()) {
747 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
748 exit(1);
749 }
750 shared_ptr<FileAsset> srcAlbumAsset = nullptr;
751 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002", g_pictures, srcAlbumAsset), true);
752 shared_ptr<FileAsset> fileAsset = nullptr;
753 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Move_test_002.jpg", srcAlbumAsset, fileAsset), true);
754 shared_ptr<FileAsset> destAlbumAsset = nullptr;
755 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002_dest", g_pictures, destAlbumAsset), true);
756 Uri sourceUri(srcAlbumAsset->GetUri());
757 Uri targetUri(destAlbumAsset->GetUri());
758 Uri newUri("");
759 int32_t ret = MediaFileExtentionUtils::Move(sourceUri, targetUri, newUri);
760 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
761 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002_dest", g_camera, destAlbumAsset), true);
762 Uri targetUriOne(destAlbumAsset->GetUri());
763 ret = MediaFileExtentionUtils::Move(sourceUri, targetUriOne, newUri);
764 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
765 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002_dest", g_videos, destAlbumAsset), true);
766 Uri targetUriTwo(destAlbumAsset->GetUri());
767 ret = MediaFileExtentionUtils::Move(sourceUri, targetUriTwo, newUri);
768 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
769 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002_dest", g_audios, destAlbumAsset), true);
770 Uri targetUriThree(destAlbumAsset->GetUri());
771 ret = MediaFileExtentionUtils::Move(sourceUri, targetUriThree, newUri);
772 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
773 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002_dest", g_documents, destAlbumAsset), true);
774 Uri targetUriFour(destAlbumAsset->GetUri());
775 ret = MediaFileExtentionUtils::Move(sourceUri, targetUriFour, newUri);
776 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
777 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Move_test_002_dest", g_download, destAlbumAsset), true);
778 Uri targetUriFive(destAlbumAsset->GetUri());
779 ret = MediaFileExtentionUtils::Move(sourceUri, targetUriFive, newUri);
780 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
781 }
782
783 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_001, TestSize.Level0)
784 {
785 if (!MediaLibraryUnitTestUtils::IsValid()) {
786 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
787 exit(1);
788 }
789 shared_ptr<FileAsset> fileAsset = nullptr;
790 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Rename_test_001.jpg", g_documents, fileAsset), true);
791 Uri sourceUri(fileAsset->GetUri());
792 Uri newUri("");
793 string displayName = "new_Rename_test_001.jpg";
794 MEDIA_DEBUG_LOG("medialib_Rename_test_001 sourceUri: %{public}s, displayName: %{public}s",
795 sourceUri.ToString().c_str(), displayName.c_str());
796 string oldPath = fileAsset->GetPath();
797 string newPath = oldPath.substr(0, oldPath.rfind('/')) + "/" + displayName;
798 MEDIA_DEBUG_LOG("medialib_Rename_test_001 oldPath: %{private}s, newPath: %{private}s",
799 oldPath.c_str(), newPath.c_str());
800 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(oldPath), true);
801 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(newPath), false);
802 int32_t ret = mediaFileExtAbility->Rename(sourceUri, displayName, newUri);
803 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(oldPath), false);
804 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(newPath), true);
805 MEDIA_DEBUG_LOG("medialib_Rename_test_001 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
806 }
807
808 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_002, TestSize.Level0)
809 {
810 if (!MediaLibraryUnitTestUtils::IsValid()) {
811 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
812 exit(1);
813 }
814 shared_ptr<FileAsset> albumAsset = nullptr;
815 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("Rename_test_002", g_documents, albumAsset), true);
816 shared_ptr<FileAsset> fileAsset = nullptr;
817 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Rename_test_002.jpg", g_documents, fileAsset), true);
818 Uri sourceUri(albumAsset->GetUri());
819 Uri newUri("");
820 string displayName = "new_Rename_test_002.png";
821 MEDIA_DEBUG_LOG("medialib_Rename_test_002 sourceUri: %{public}s, displayName: %{public}s",
822 sourceUri.ToString().c_str(), displayName.c_str());
823 string oldPath = albumAsset->GetPath();
824 string newPath = oldPath.substr(0, oldPath.rfind('/')) + "/" + displayName;
825 MEDIA_DEBUG_LOG("medialib_Rename_test_002 oldPath: %{private}s, newPath: %{private}s",
826 oldPath.c_str(), newPath.c_str());
827 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(oldPath), true);
828 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(newPath), false);
829 int32_t ret = MediaFileExtentionUtils::Rename(sourceUri, displayName, newUri);
830 EXPECT_EQ(ret, 0);
831 }
832
833 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_003, TestSize.Level0)
834 {
835 if (!MediaLibraryUnitTestUtils::IsValid()) {
836 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
837 exit(1);
838 }
839 Uri sourceUri(ReturnUri(COMMON_PREFIX, INVALID_URI));
840 Uri newUri("");
841 string displayName = "rename";
842 MEDIA_DEBUG_LOG("medialib_Rename_test_003 sourceUri: %{public}s, displayName: %{public}s",
843 sourceUri.ToString().c_str(), displayName.c_str());
844 int32_t ret = mediaFileExtAbility->Rename(sourceUri, displayName, newUri);
845 EXPECT_EQ(ret, JS_E_URI);
846 MEDIA_DEBUG_LOG("medialib_Rename_test_003 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
847 }
848
849 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_004, TestSize.Level0)
850 {
851 if (!MediaLibraryUnitTestUtils::IsValid()) {
852 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
853 exit(1);
854 }
855 Uri sourceUri(ReturnUri(DISTRIBUTED_PREFIX, COMMON_URI));
856 Uri newUri("");
857 string displayName = "rename";
858 MEDIA_DEBUG_LOG("medialib_Rename_test_004 sourceUri: %{public}s, displayName: %{public}s",
859 sourceUri.ToString().c_str(), displayName.c_str());
860 int32_t ret = mediaFileExtAbility->Rename(sourceUri, displayName, newUri);
861 EXPECT_EQ(ret, JS_E_URI);
862 MEDIA_DEBUG_LOG("medialib_Rename_test_004 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
863 }
864
865 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_005, TestSize.Level0)
866 {
867 if (!MediaLibraryUnitTestUtils::IsValid()) {
868 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
869 exit(1);
870 }
871 shared_ptr<FileAsset> fileAsset = nullptr;
872 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Rename_test_005.jpg", g_documents, fileAsset), true);
873 Uri sourceUri(fileAsset->GetUri());
874 Uri newUri("");
875 string displayName = INVALID_FILE_NAME;
876 MEDIA_DEBUG_LOG("medialib_Rename_test_005 sourceUri: %{public}s, displayName: %{public}s",
877 sourceUri.ToString().c_str(), displayName.c_str());
878 int32_t ret = mediaFileExtAbility->Rename(sourceUri, displayName, newUri);
879 EXPECT_EQ(ret, JS_E_DISPLAYNAME);
880 MEDIA_DEBUG_LOG("medialib_Rename_test_005 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
881 }
882
883 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_006, TestSize.Level0)
884 {
885 if (!MediaLibraryUnitTestUtils::IsValid()) {
886 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
887 exit(1);
888 }
889 shared_ptr<FileAsset> fileAsset = nullptr;
890 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Rename_test_006.jpg", g_documents, fileAsset), true);
891 shared_ptr<FileAsset> tempFileAsset = nullptr;
892 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("new_Rename_test_006.jpg", g_documents, tempFileAsset), true);
893 Uri sourceUri(fileAsset->GetUri());
894 Uri newUri("");
895 string displayName = "new_Rename_test_006.jpg";
896 MEDIA_DEBUG_LOG("medialib_Rename_test_006 sourceUri: %{public}s, displayName: %{public}s",
897 sourceUri.ToString().c_str(), displayName.c_str());
898 int32_t ret = mediaFileExtAbility->Rename(sourceUri, displayName, newUri);
899 EXPECT_EQ(ret, JS_ERR_FILE_EXIST);
900 MEDIA_DEBUG_LOG("medialib_Rename_test_006 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
901 }
902
903 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_007, TestSize.Level0)
904 {
905 if (!MediaLibraryUnitTestUtils::IsValid()) {
906 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
907 exit(1);
908 }
909 shared_ptr<FileAsset> fileAsset = nullptr;
910 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("Rename_test_007.jpg", g_documents, fileAsset), true);
911 Uri sourceUri(fileAsset->GetUri());
912 Uri newUri("");
913 string displayName = "Rename_test_007.txt";
914 MEDIA_DEBUG_LOG("medialib_Rename_test_007 sourceUri: %{public}s, displayName: %{public}s",
915 sourceUri.ToString().c_str(), displayName.c_str());
916 int32_t ret = mediaFileExtAbility->Rename(sourceUri, displayName, newUri);
917 EXPECT_EQ(ret, E_SUCCESS);
918 MEDIA_DEBUG_LOG("medialib_Rename_test_007 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
919 }
920
921 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_008, TestSize.Level0)
922 {
923 Uri sourceUri("");
924 Uri parentUri(g_pictures->GetUri());
925 int32_t ret = MediaFileExtentionUtils::CreateFile(parentUri, "Rename_test_007.jpg", sourceUri);
926 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
927 Uri newUri("");
928 string displayName = "new_Rename_test_007.jpg";
929 ret = MediaFileExtentionUtils::Rename(sourceUri, displayName, newUri);
930 EXPECT_EQ(ret, E_URI_INVALID);
931 Uri parentUriOne(g_documents->GetUri());
932 ret = MediaFileExtentionUtils::CreateFile(parentUriOne, "Rename_test_007.jpg", sourceUri);
933 EXPECT_GT(ret, E_SUCCESS);
934 ret = MediaFileExtentionUtils::Rename(sourceUri, displayName, newUri);
935 EXPECT_EQ(ret, E_SUCCESS);
936 Uri parentUriTwo(g_download->GetUri());
937 ret = MediaFileExtentionUtils::CreateFile(parentUriTwo, "Rename_test_007.jpg", sourceUri);
938 EXPECT_GT(ret, E_SUCCESS);
939 ret = MediaFileExtentionUtils::Rename(sourceUri, displayName, newUri);
940 EXPECT_EQ(ret, E_SUCCESS);
941 }
942
DisplayFileList(const vector<FileInfo> & fileList)943 void DisplayFileList(const vector<FileInfo> &fileList)
944 {
945 MEDIA_DEBUG_LOG("DisplayFileList::Start");
946 for (auto t : fileList) {
947 MEDIA_DEBUG_LOG("file.uri: %s, file.fileName: %s, file.mode: %d, file.mimeType: %s",
948 t.uri.c_str(), t.fileName.c_str(), t.mode, t.mimeType.c_str());
949 }
950 MEDIA_DEBUG_LOG("DisplayFileList::End");
951 }
952
ListFileFromRootResult(vector<FileInfo> rootFileList,int offset,int maxCount)953 void ListFileFromRootResult(vector<FileInfo> rootFileList, int offset, int maxCount)
954 {
955 const size_t URI_FILE_ROOT_FILE_SIZE = 2;
956 const size_t URI_MEDIA_ROOT_IMAGE_SIZE = 0;
957 const size_t URI_MEDIA_ROOT_VIDEO_SIZE = 0;
958 const size_t URI_MEDIA_ROOT_AUDIO_SIZE = 0;
959 FileAccessFwk::FileFilter filter;
960 // URI_FILE_ROOT & URI_MEDIA_ROOT
961 for (auto mediaRootInfo : rootFileList) {
962 vector<FileInfo> fileList;
963 auto ret = mediaFileExtAbility->ListFile(mediaRootInfo, offset, maxCount, filter, fileList);
964 EXPECT_EQ(ret, E_SUCCESS);
965
966 // URI_FILE_ROOT
967 if (mediaRootInfo.mimeType == DEFAULT_FILE_MIME_TYPE) {
968 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_FILE_ROOT uri: %{public}s", mediaRootInfo.uri.c_str());
969 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_FILE_ROOT fileList.size(): %{public}d",
970 (int)fileList.size());
971 DisplayFileList(fileList);
972 EXPECT_EQ(fileList.size(), URI_FILE_ROOT_FILE_SIZE);
973 continue;
974 }
975
976 // URI_MEDIA_ROOT image
977 if (mediaRootInfo.mimeType == DEFAULT_IMAGE_MIME_TYPE) {
978 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_MEDIA_ROOT uri: %{public}s", mediaRootInfo.uri.c_str());
979 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_MEDIA_ROOT fileList.size(): %{public}d",
980 (int)fileList.size());
981 DisplayFileList(fileList);
982 EXPECT_GT(fileList.size(), URI_MEDIA_ROOT_IMAGE_SIZE);
983 }
984
985 // URI_MEDIA_ROOT video
986 if (mediaRootInfo.mimeType == DEFAULT_VIDEO_MIME_TYPE) {
987 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_MEDIA_ROOT uri: %{public}s", mediaRootInfo.uri.c_str());
988 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_MEDIA_ROOT fileList.size(): %{public}d",
989 (int)fileList.size());
990 DisplayFileList(fileList);
991 EXPECT_EQ(fileList.size(), URI_MEDIA_ROOT_VIDEO_SIZE);
992 }
993
994 // URI_MEDIA_ROOT audio
995 if (mediaRootInfo.mimeType == DEFAULT_AUDIO_MIME_TYPE) {
996 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_MEDIA_ROOT uri: %{public}s", mediaRootInfo.uri.c_str());
997 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_MEDIA_ROOT fileList.size(): %{public}d",
998 (int)fileList.size());
999 DisplayFileList(fileList);
1000 EXPECT_EQ(fileList.size(), URI_MEDIA_ROOT_AUDIO_SIZE);
1001 }
1002 }
1003 }
1004
1005 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_ListFile_test_001, TestSize.Level0)
1006 {
1007 if (!MediaLibraryUnitTestUtils::IsValid()) {
1008 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1009 exit(1);
1010 }
1011
1012 shared_ptr<FileAsset> albumAsset = nullptr;
1013 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("ListFile_test_001", g_pictures, albumAsset), true);
1014 shared_ptr<FileAsset> tempAsset = nullptr;
1015 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("ListFile_test_001", albumAsset, tempAsset), true);
1016 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_test_001_1.jpg", albumAsset, tempAsset), true);
1017 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_test_001_2.jpg", albumAsset, tempAsset), true);
1018 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_test_001_3.jpg", albumAsset, tempAsset), true);
1019 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_test_001_1.mp4", g_videos, tempAsset), true);
1020 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::CREATE,
1021 MediaLibraryApi::API_10);
1022 string name = "photo.jpg";
1023 NativeRdb::ValuesBucket values;
1024 values.PutString(MediaColumn::MEDIA_NAME, name);
1025 values.PutInt(MediaColumn::MEDIA_TYPE, MediaType::MEDIA_TYPE_IMAGE);
1026 cmd.SetValueBucket(values);
1027 int32_t ret = MediaLibraryPhotoOperations::Create(cmd);
1028 EXPECT_GE(ret, 0);
1029 const int64_t offset = 0;
1030 const int64_t maxCount = 100;
1031 FileAccessFwk::FileFilter filter;
1032
1033 // URI_ROOT
1034 FileInfo rootInfo;
1035 rootInfo.uri = ReturnUri(COMMON_PREFIX, ROOT_URI);
1036 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_ROOT uri: %{public}s", rootInfo.uri.c_str());
1037 vector<FileInfo> rootFileList;
1038 ret = mediaFileExtAbility->ListFile(rootInfo, offset, maxCount, filter, rootFileList);
1039 EXPECT_EQ(ret, E_SUCCESS);
1040 MEDIA_DEBUG_LOG("medialib_ListFile_test_001 URI_ROOT fileList.size(): %{public}d", (int)rootFileList.size());
1041 DisplayFileList(rootFileList);
1042 EXPECT_EQ(rootFileList.size(), 4);
1043
1044 ListFileFromRootResult(rootFileList, offset, maxCount);
1045 }
1046
ListFileTestLimit(FileInfo dirInfo)1047 void ListFileTestLimit(FileInfo dirInfo)
1048 {
1049 const int64_t OFFSET_1 = 0;
1050 const int64_t OFFSET_2 = 5;
1051 const int64_t MAX_COUNT_1 = 5;
1052 const int64_t MAX_COUNT_2 = 100;
1053 vector<pair<int64_t, int64_t>> limits = { make_pair(OFFSET_1, MAX_COUNT_1),
1054 make_pair(OFFSET_2, MAX_COUNT_1), make_pair(OFFSET_1, MAX_COUNT_2), make_pair(OFFSET_2, MAX_COUNT_2) };
1055 const int DIR_RESULT = 8;
1056
1057 FileAccessFwk::FileFilter filter;
1058 for (auto limit : limits) {
1059 // URI_DIR
1060 dirInfo.mimeType = DEFAULT_FILE_MIME_TYPE;
1061 vector<FileInfo> dirFileList;
1062 auto ret = mediaFileExtAbility->ListFile(dirInfo, limit.first, limit.second, filter, dirFileList);
1063 EXPECT_EQ(ret, E_SUCCESS);
1064 EXPECT_EQ(dirFileList.size(), min((DIR_RESULT - limit.first), limit.second));
1065 }
1066 }
1067
ListFileTestFilter(FileInfo dirInfo)1068 void ListFileTestFilter(FileInfo dirInfo)
1069 {
1070 const int FILTER_COUNT = 3;
1071 const string SUFFIX_1 = ".jpg";
1072 const string SUFFIX_2 = ".png";
1073 const int32_t JPG_COUNT = 4;
1074 const int32_t PNG_COUNT = 2;
1075 const vector<int32_t> DIR_RESULT = {JPG_COUNT, PNG_COUNT, JPG_COUNT + PNG_COUNT};
1076 const vector<int32_t> ALBUM_RESULT = {JPG_COUNT, PNG_COUNT, JPG_COUNT + PNG_COUNT};
1077 vector<FileAccessFwk::FileFilter> filters;
1078 FileAccessFwk::FileFilter tempFilter;
1079 tempFilter.SetHasFilter(true);
1080 tempFilter.SetSuffix({ SUFFIX_1 });
1081 filters.push_back(tempFilter);
1082 tempFilter.SetSuffix({ SUFFIX_2 });
1083 filters.push_back(tempFilter);
1084 tempFilter.SetSuffix({ SUFFIX_1, SUFFIX_2 });
1085 filters.push_back(tempFilter);
1086
1087 const int64_t offset = 0;
1088 const int64_t maxCount = 100;
1089 for (size_t i = 0; i < FILTER_COUNT; i++) {
1090 MEDIA_ERR_LOG("medialib_ListFile_test_002:: filter.hasFilter: %d, filter.suffix: %s",
1091 (int)filters[i].GetHasFilter(), filters[i].GetSuffix()[0].c_str());
1092 // URI_DIR
1093 dirInfo.mimeType = DEFAULT_FILE_MIME_TYPE;
1094 vector<FileInfo> dirFileList;
1095 auto ret = mediaFileExtAbility->ListFile(dirInfo, offset, maxCount, filters[i], dirFileList);
1096 MEDIA_ERR_LOG("medialib_ListFile_test_002:: dirFileList.size(): %d", (int)dirFileList.size());
1097 DisplayFileList(dirFileList);
1098 EXPECT_EQ(ret, E_SUCCESS);
1099 EXPECT_EQ(dirFileList.size(), DIR_RESULT[i]);
1100 }
1101 }
1102
1103 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_ListFile_test_002, TestSize.Level0)
1104 {
1105 if (!MediaLibraryUnitTestUtils::IsValid()) {
1106 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1107 exit(1);
1108 }
1109 shared_ptr<FileAsset> albumAsset = nullptr;
1110 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("ListFile_test_002", g_documents, albumAsset), true);
1111 shared_ptr<FileAsset> tempAsset = nullptr;
1112 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("ListFile_test_002", albumAsset, tempAsset), true);
1113 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("ListFile_002", albumAsset, tempAsset), true);
1114 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_test_002.jpg", albumAsset, tempAsset), true);
1115 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_test_002_1.jpg", albumAsset, tempAsset), true);
1116 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_test_002.png", albumAsset, tempAsset), true);
1117 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_002.jpg", albumAsset, tempAsset), true);
1118 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_002_1.jpg", albumAsset, tempAsset), true);
1119 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ListFile_002.png", albumAsset, tempAsset), true);
1120
1121 const int32_t DIR_RESULT = 8;
1122 const int64_t offset = 0;
1123 const int64_t maxCount = 100;
1124 FileAccessFwk::FileFilter filter;
1125
1126 // URI_DIR
1127 FileInfo dirInfo;
1128 dirInfo.uri = albumAsset->GetUri();
1129 dirInfo.mimeType = DEFAULT_FILE_MIME_TYPE;
1130 MEDIA_DEBUG_LOG("medialib_ListFile_test_002 URI_DIR uri: %{public}s", dirInfo.uri.c_str());
1131 vector<FileInfo> dirFileList;
1132 auto ret = mediaFileExtAbility->ListFile(dirInfo, offset, maxCount, filter, dirFileList);
1133 EXPECT_EQ(ret, E_SUCCESS);
1134 MEDIA_DEBUG_LOG("medialib_ListFile_test_002 URI_DIR fileList.size(): %{public}d", (int)dirFileList.size());
1135 DisplayFileList(dirFileList);
1136 EXPECT_EQ(dirFileList.size(), DIR_RESULT);
1137
1138 // test limit and filter
1139 FileInfo fileInfo;
1140 fileInfo.uri = albumAsset->GetUri();
1141 ListFileTestLimit(fileInfo);
1142 ListFileTestFilter(fileInfo);
1143 }
1144
1145 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetRoots_test_001, TestSize.Level0)
1146 {
1147 if (!MediaLibraryUnitTestUtils::IsValid()) {
1148 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1149 exit(1);
1150 }
1151 vector<RootInfo> rootList;
1152 auto ret = mediaFileExtAbility->GetRoots(rootList);
1153 EXPECT_EQ(ret, E_SUCCESS);
1154 MEDIA_DEBUG_LOG("medialib_GetRoots_test_001 rootList.size() %{public}lu", (long)rootList.size());
1155 }
1156
InitScanFile(shared_ptr<FileAsset> & albumAsset)1157 inline void InitScanFile(shared_ptr<FileAsset> &albumAsset)
1158 {
1159 shared_ptr<FileAsset> tempAsset = nullptr;
1160 shared_ptr<FileAsset> albumAsset2 = nullptr;
1161 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("ScanFile_test", g_documents, albumAsset), true);
1162 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("ScanFile_test", albumAsset, albumAsset2), true);
1163 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_1.jpg", albumAsset, tempAsset), true);
1164 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_2.jpg", albumAsset, tempAsset), true);
1165 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_3.png", albumAsset, tempAsset), true);
1166 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_4.jpg", albumAsset, tempAsset), true);
1167 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_5.jpg", albumAsset, tempAsset), true);
1168 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_6.jpg", albumAsset2, tempAsset), true);
1169 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_7.png", albumAsset2, tempAsset), true);
1170 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("ScanFile_test_8.jpg", albumAsset2, tempAsset), true);
1171 }
1172
1173 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_ScanFile_test_001, TestSize.Level0)
1174 {
1175 if (!MediaLibraryUnitTestUtils::IsValid()) {
1176 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1177 exit(1);
1178 }
1179
1180 shared_ptr<FileAsset> albumAsset = nullptr;
1181 InitScanFile(albumAsset);
1182
1183 int64_t offset = 0;
1184 int64_t maxCount = 100;
1185 FileAccessFwk::FileFilter filter;
1186
1187 // URI_DIR
1188 FileInfo dirInfo;
1189 dirInfo.uri = albumAsset->GetUri();
1190 dirInfo.mimeType = DEFAULT_FILE_MIME_TYPE;
1191 MEDIA_DEBUG_LOG("medialib_ScanFile_test_001 URI_DIR uri: %{public}s", dirInfo.uri.c_str());
1192 vector<FileInfo> dirFileList;
1193 int32_t ret = MediaFileExtentionUtils::ScanFile(dirInfo, offset, maxCount, filter, dirFileList);
1194 EXPECT_EQ(ret, E_SUCCESS);
1195 EXPECT_EQ(dirFileList.size(), 8);
1196
1197 vector<FileInfo> limitDirFileList1;
1198 ret = MediaFileExtentionUtils::ScanFile(dirInfo, offset, 5, filter, limitDirFileList1);
1199 EXPECT_EQ(ret, E_SUCCESS);
1200 EXPECT_EQ(limitDirFileList1.size(), 5);
1201
1202 vector<FileInfo> limitDirFileList2;
1203 ret = MediaFileExtentionUtils::ScanFile(dirInfo, 5, maxCount, filter, limitDirFileList2);
1204 EXPECT_EQ(ret, E_SUCCESS);
1205 EXPECT_EQ(limitDirFileList2.size(), 3);
1206 }
1207
1208 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_ScanFile_test_002, TestSize.Level0)
1209 {
1210 if (!MediaLibraryUnitTestUtils::IsValid()) {
1211 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1212 exit(1);
1213 }
1214 shared_ptr<FileAsset> albumAsset = nullptr;
1215 InitScanFile(albumAsset);
1216
1217 int64_t offset = 0;
1218 int64_t maxCount = 100;
1219 FileAccessFwk::FileFilter filter;
1220
1221 // URI_DIR
1222 FileInfo dirInfo;
1223 dirInfo.uri = "datashare:///media/root";
1224 dirInfo.mimeType = DEFAULT_FILE_MIME_TYPE;
1225 MEDIA_DEBUG_LOG("medialib_ListFile_test_002 URI_DIR uri: %{public}s", dirInfo.uri.c_str());
1226 vector<FileInfo> dirFileList;
1227 auto ret = mediaFileExtAbility->ScanFile(dirInfo, offset, maxCount, filter, dirFileList);
1228 EXPECT_EQ(ret, E_SUCCESS);
1229 EXPECT_GT(dirFileList.size(), 4);
1230
1231 vector<FileInfo> limitDirFileList1;
1232 ret = mediaFileExtAbility->ScanFile(dirInfo, offset, 5, filter, limitDirFileList1);
1233 EXPECT_EQ(ret, E_SUCCESS);
1234 EXPECT_EQ(limitDirFileList1.size(), 5);
1235
1236 vector<FileInfo> limitDirFileList2;
1237 ret = mediaFileExtAbility->ScanFile(dirInfo, 5, maxCount, filter, limitDirFileList2);
1238 EXPECT_EQ(ret, E_SUCCESS);
1239 EXPECT_GT(limitDirFileList2.size(), 3);
1240 }
1241
1242 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_ScanFile_test_003, TestSize.Level0)
1243 {
1244 if (!MediaLibraryUnitTestUtils::IsValid()) {
1245 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1246 exit(1);
1247 }
1248
1249 shared_ptr<FileAsset> albumAsset = nullptr;
1250 InitScanFile(albumAsset);
1251
1252 int64_t offset = 0;
1253 int64_t maxCount = 100;
1254 FileAccessFwk::FileFilter filter;
1255 vector<string> suffix { ".jpg" };
1256 filter.SetSuffix(suffix);
1257 // URI_DIR
1258 FileInfo dirInfo;
1259 dirInfo.uri = albumAsset->GetUri();
1260 dirInfo.mimeType = DEFAULT_FILE_MIME_TYPE;
1261 MEDIA_DEBUG_LOG("medialib_ListFile_test_003 URI_DIR uri: %{public}s", dirInfo.uri.c_str());
1262 vector<FileInfo> dirFileList;
1263 auto ret = mediaFileExtAbility->ScanFile(dirInfo, offset, maxCount, filter, dirFileList);
1264 EXPECT_EQ(ret, E_SUCCESS);
1265 EXPECT_EQ(dirFileList.size(), 6);
1266
1267 vector<FileInfo> limitDirFileList1;
1268 ret = mediaFileExtAbility->ScanFile(dirInfo, offset, 5, filter, limitDirFileList1);
1269 EXPECT_EQ(ret, E_SUCCESS);
1270 EXPECT_EQ(limitDirFileList1.size(), 5);
1271
1272 vector<FileInfo> limitDirFileList2;
1273 ret = mediaFileExtAbility->ScanFile(dirInfo, 5, maxCount, filter, limitDirFileList2);
1274 EXPECT_EQ(ret, E_SUCCESS);
1275 EXPECT_EQ(limitDirFileList2.size(), 1);
1276 }
1277
PrintFileInfo(const FileInfo & fileInfo,const string & testcase)1278 void PrintFileInfo(const FileInfo &fileInfo, const string &testcase)
1279 {
1280 MEDIA_INFO_LOG("testcase: %{public}s FileInfo uri: %{public}s, fileName: %{public}s, mode: %{public}d",
1281 testcase.c_str(), fileInfo.uri.c_str(), fileInfo.fileName.c_str(), fileInfo.mode);
1282 MEDIA_INFO_LOG("testcase: %{public}s FileInfo size: %{public}lld, mtime: %{public}lld, mimeType: %{public}s",
1283 testcase.c_str(), (long long)fileInfo.size, (long long)fileInfo.mtime, fileInfo.mimeType.c_str());
1284 }
1285
1286 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromUri_test_001, TestSize.Level0)
1287 {
1288 Uri uri(ReturnUri(MEDIALIBRARY_MEDIA_PREFIX, MEDIALIBRARY_ROOT));
1289 FileInfo fileInfo;
1290 auto ret = mediaFileExtAbility->GetFileInfoFromUri(uri, fileInfo);
1291 PrintFileInfo(fileInfo, "medialib_GetFileInfoFromUri_test_001");
1292 EXPECT_EQ(ret, E_SUCCESS);
1293 }
1294
1295 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromUri_test_002, TestSize.Level0)
1296 {
1297 Uri uri(ReturnUri(MEDIALIBRARY_MEDIA_PREFIX, MEDIALIBRARY_ROOT, MEDIALIBRARY_TYPE_FILE_URI));
1298 FileInfo fileInfo;
1299 auto ret = mediaFileExtAbility->GetFileInfoFromUri(uri, fileInfo);
1300 PrintFileInfo(fileInfo, "medialib_GetFileInfoFromUri_test_002");
1301 EXPECT_EQ(ret, E_SUCCESS);
1302 }
1303
1304 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromUri_test_003, TestSize.Level0)
1305 {
1306 Uri uri(ReturnUri(MEDIALIBRARY_MEDIA_PREFIX, MEDIALIBRARY_ROOT, MEDIALIBRARY_TYPE_IMAGE_URI));
1307 FileInfo fileInfo;
1308 auto ret = mediaFileExtAbility->GetFileInfoFromUri(uri, fileInfo);
1309 PrintFileInfo(fileInfo, "medialib_GetFileInfoFromUri_test_003");
1310 EXPECT_EQ(ret, E_SUCCESS);
1311 }
1312
1313 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromUri_test_004, TestSize.Level0)
1314 {
1315 Uri uri(ReturnUri(MEDIALIBRARY_MEDIA_PREFIX, MEDIALIBRARY_ROOT, MEDIALIBRARY_TYPE_VIDEO_URI));
1316 FileInfo fileInfo;
1317 auto ret = mediaFileExtAbility->GetFileInfoFromUri(uri, fileInfo);
1318 PrintFileInfo(fileInfo, "medialib_GetFileInfoFromUri_test_004");
1319 EXPECT_EQ(ret, E_SUCCESS);
1320 }
1321
1322 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromUri_test_005, TestSize.Level0)
1323 {
1324 Uri uri(ReturnUri(MEDIALIBRARY_MEDIA_PREFIX, MEDIALIBRARY_ROOT, MEDIALIBRARY_TYPE_AUDIO_URI));
1325 FileInfo fileInfo;
1326 auto ret = mediaFileExtAbility->GetFileInfoFromUri(uri, fileInfo);
1327 PrintFileInfo(fileInfo, "medialib_GetFileInfoFromUri_test_005");
1328 EXPECT_EQ(ret, E_SUCCESS);
1329 }
1330
1331 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromUri_test_006, TestSize.Level0)
1332 {
1333 if (!MediaLibraryUnitTestUtils::IsValid()) {
1334 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1335 exit(1);
1336 }
1337 shared_ptr<FileAsset> albumAsset = nullptr;
1338 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("GetFileInfoFromUri_test_006", g_download, albumAsset), true);
1339 shared_ptr<FileAsset> fileAsset = nullptr;
1340 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("GetFileInfoFromUri_test_006.jpg", albumAsset, fileAsset), true);
1341 Uri uri(fileAsset->GetUri());
1342 FileInfo fileInfo;
1343 auto ret = mediaFileExtAbility->GetFileInfoFromUri(uri, fileInfo);
1344 PrintFileInfo(fileInfo, "medialib_GetFileInfoFromUri_test_006");
1345 EXPECT_EQ(ret, E_SUCCESS);
1346
1347 int32_t fileMode = DOCUMENT_FLAG_REPRESENTS_FILE | DOCUMENT_FLAG_SUPPORTS_READ | DOCUMENT_FLAG_SUPPORTS_WRITE;
1348 EXPECT_EQ(fileInfo.fileName, "GetFileInfoFromUri_test_006.jpg");
1349 EXPECT_EQ(fileInfo.size, 0);
1350 EXPECT_EQ(fileInfo.uri, fileAsset->GetUri());
1351 EXPECT_EQ(fileInfo.mtime, fileAsset->GetDateModified());
1352 EXPECT_EQ(fileInfo.mode, fileMode);
1353 }
1354
1355 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromUri_test_007, TestSize.Level0)
1356 {
1357 if (!MediaLibraryUnitTestUtils::IsValid()) {
1358 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1359 exit(1);
1360 }
1361 shared_ptr<FileAsset> albumAsset = nullptr;
1362 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("GetFileInfoFromUri_test_007", g_pictures, albumAsset), true);
1363 Uri uri(albumAsset->GetUri());
1364 FileInfo albumInfo;
1365 auto ret = mediaFileExtAbility->GetFileInfoFromUri(uri, albumInfo);
1366 PrintFileInfo(albumInfo, "medialib_GetFileInfoFromUri_test_007");
1367 EXPECT_EQ(ret, E_SUCCESS);
1368
1369 int32_t albumMode = DOCUMENT_FLAG_REPRESENTS_DIR | DOCUMENT_FLAG_SUPPORTS_READ | DOCUMENT_FLAG_SUPPORTS_WRITE;
1370 EXPECT_EQ(albumInfo.fileName, "GetFileInfoFromUri_test_007");
1371 EXPECT_EQ(albumInfo.size, 0);
1372 EXPECT_NE(albumAsset->GetSize(), 0);
1373 EXPECT_EQ(albumInfo.uri, albumAsset->GetUri());
1374 EXPECT_EQ(albumInfo.mtime, albumAsset->GetDateModified());
1375 EXPECT_EQ(albumInfo.mode, albumMode);
1376 }
1377
1378 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromRelativePath_test_001, TestSize.Level0)
1379 {
1380 if (!MediaLibraryUnitTestUtils::IsValid()) {
1381 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1382 exit(1);
1383 }
1384 shared_ptr<FileAsset> albumAsset = nullptr;
1385 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateAlbum("GetFileInfoFromRelativePath_001", g_pictures, albumAsset), true);
1386 FileInfo parentInfo;
1387 auto ret = mediaFileExtAbility->GetFileInfoFromRelativePath(albumAsset->GetRelativePath(), parentInfo);
1388 PrintFileInfo(parentInfo, "medialib_GetFileInfoFromRelativePath_test_001");
1389 EXPECT_EQ(ret, E_SUCCESS);
1390
1391 int32_t albumMode = DOCUMENT_FLAG_REPRESENTS_DIR | DOCUMENT_FLAG_SUPPORTS_READ | DOCUMENT_FLAG_SUPPORTS_WRITE;
1392 EXPECT_EQ(parentInfo.fileName, g_pictures->GetDisplayName());
1393 EXPECT_EQ(parentInfo.size, 0);
1394 EXPECT_EQ(parentInfo.uri, g_pictures->GetUri());
1395 EXPECT_EQ(parentInfo.mtime, g_pictures->GetDateModified());
1396 EXPECT_EQ(parentInfo.mode, albumMode);
1397 EXPECT_EQ(parentInfo.relativePath, "");
1398 }
1399
1400 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromRelativePath_test_002, TestSize.Level0)
1401 {
1402 if (!MediaLibraryUnitTestUtils::IsValid()) {
1403 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1404 exit(1);
1405 }
1406 shared_ptr<FileAsset> fileAsset = nullptr;
1407 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("GetFileInfoFromRelativePath_002.jpg", g_pictures, fileAsset),
1408 true);
1409 FileInfo parentInfo;
1410 auto ret = mediaFileExtAbility->GetFileInfoFromRelativePath(fileAsset->GetRelativePath(), parentInfo);
1411 PrintFileInfo(parentInfo, "medialib_GetFileInfoFromRelativePath_test_002");
1412 EXPECT_EQ(ret, E_SUCCESS);
1413
1414 int32_t albumMode = DOCUMENT_FLAG_REPRESENTS_DIR | DOCUMENT_FLAG_SUPPORTS_READ | DOCUMENT_FLAG_SUPPORTS_WRITE;
1415 EXPECT_EQ(parentInfo.fileName, g_pictures->GetDisplayName());
1416 EXPECT_EQ(parentInfo.size, 0);
1417 EXPECT_EQ(parentInfo.uri, g_pictures->GetUri());
1418 EXPECT_EQ(parentInfo.mode, albumMode);
1419 EXPECT_EQ(parentInfo.relativePath, "");
1420 }
1421
1422 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromRelativePath_test_003, TestSize.Level0)
1423 {
1424 if (!MediaLibraryUnitTestUtils::IsValid()) {
1425 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1426 exit(1);
1427 }
1428 FileInfo rootInfo;
1429 auto ret = mediaFileExtAbility->GetFileInfoFromRelativePath("", rootInfo);
1430 PrintFileInfo(rootInfo, "medialib_GetFileInfoFromRelativePath_test_003");
1431 EXPECT_EQ(ret, E_SUCCESS);
1432
1433 int32_t albumReadOnlyMode = DOCUMENT_FLAG_REPRESENTS_DIR | DOCUMENT_FLAG_SUPPORTS_READ;
1434 EXPECT_EQ(rootInfo.fileName, "MEDIA_TYPE_FILE");
1435 EXPECT_EQ(rootInfo.size, 0);
1436 EXPECT_EQ(rootInfo.uri, ReturnUri(MEDIALIBRARY_DATA_URI, MEDIALIBRARY_TYPE_FILE_URI));
1437 EXPECT_EQ(rootInfo.mtime, 0);
1438 EXPECT_EQ(rootInfo.mode, albumReadOnlyMode);
1439 EXPECT_EQ(rootInfo.relativePath, "");
1440 }
1441
1442 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_GetFileInfoFromRelativePath_test_004, TestSize.Level0)
1443 {
1444 if (!MediaLibraryUnitTestUtils::IsValid()) {
1445 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1446 exit(1);
1447 }
1448
1449 FileInfo parentInfo;
1450 string testRelativePath = "Pictures/";
1451 EXPECT_EQ(mediaFileExtAbility->GetFileInfoFromRelativePath(testRelativePath, parentInfo), E_SUCCESS);
1452
1453 testRelativePath = "Pictures";
1454 EXPECT_EQ(mediaFileExtAbility->GetFileInfoFromRelativePath(testRelativePath, parentInfo), E_SUCCESS);
1455
1456 shared_ptr<FileAsset> fileAsset = nullptr;
1457 ASSERT_EQ(MediaLibraryUnitTestUtils::CreateFile("GetFileInfoFromRelativePath_004.jpg", g_pictures, fileAsset),
1458 true);
1459 testRelativePath = "Pictures/GetFileInfoFromRelativePath_004.jpg";
1460 EXPECT_EQ(mediaFileExtAbility->GetFileInfoFromRelativePath(testRelativePath, parentInfo), E_SUCCESS);
1461 }
1462
MediaFileExtensionCheck(const shared_ptr<FileAsset> & parent,const unordered_set<string> extensions,const string & title,bool expect)1463 void MediaFileExtensionCheck(const shared_ptr<FileAsset> &parent, const unordered_set<string> extensions,
1464 const string &title, bool expect)
1465 {
1466 Uri parentUri(parent->GetUri());
1467 Uri newUri("");
1468
1469 for (const auto &extension : extensions) {
1470 string displayName = title + "." + extension;
1471 string filePath = parent->GetPath() + "/" + displayName;
1472 int32_t ret = mediaFileExtAbility->CreateFile(parentUri, displayName, newUri);
1473 if (expect) {
1474 EXPECT_EQ(ret, E_SUCCESS);
1475 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(filePath), true);
1476 } else {
1477 EXPECT_NE(ret, E_SUCCESS);
1478 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(filePath), false);
1479 }
1480 if (expect && ret) {
1481 MEDIA_INFO_LOG("Root dir: %{private}s, file: %{public}s, path: %{private}s, CreateFile ret: %{public}d",
1482 parent->GetDisplayName().c_str(), displayName.c_str(), filePath.c_str(), ret);
1483 }
1484 }
1485 }
1486
DocumentsExtensionCheck(const shared_ptr<FileAsset> & parent,const string & title,bool expect)1487 void DocumentsExtensionCheck(const shared_ptr<FileAsset> &parent, const string &title, bool expect)
1488 {
1489 const unordered_set<string> extensions = { ".jpg1", ".txt" };
1490
1491 Uri parentUri(parent->GetUri());
1492 Uri newUri("");
1493
1494 for (const auto &extension : extensions) {
1495 string displayName = title + extension;
1496 string filePath = parent->GetPath() + "/" + displayName;
1497 int32_t ret = mediaFileExtAbility->CreateFile(parentUri, displayName, newUri);
1498 if (expect) {
1499 EXPECT_EQ(ret, E_SUCCESS);
1500 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(filePath), true);
1501 } else {
1502 EXPECT_NE(ret, E_SUCCESS);
1503 EXPECT_EQ(MediaLibraryUnitTestUtils::IsFileExists(filePath), false);
1504 }
1505 if (expect && ret) {
1506 MEDIA_ERR_LOG("Root dir: %{private}s, file: %{public}s, path: %{private}s, CreateFile ret: %{public}d",
1507 parent->GetDisplayName().c_str(), displayName.c_str(), filePath.c_str(), ret);
1508 }
1509 }
1510 }
1511
SpecialCharacterExtensionCheck(const shared_ptr<FileAsset> & parent,const string & title,bool expect)1512 void SpecialCharacterExtensionCheck(const shared_ptr<FileAsset> &parent, const string &title, bool expect)
1513 {
1514 Uri parentUri(parent->GetUri());
1515 Uri newUri("");
1516
1517 const int32_t MAX_ASCII = 127;
1518 for (int i = 0; i <= MAX_ASCII; i ++) {
1519 string displayName = title + "." + static_cast<char>(i);
1520 string filePath = parent->GetPath() + "/" + displayName;
1521 static const string DISPLAYNAME_REGEX_CHECK = R"([\.\\/:*?"'`<>|{}\[\]])";
1522 std::regex express(DISPLAYNAME_REGEX_CHECK);
1523 bool bValid = std::regex_search(displayName, express);
1524 int32_t ret = MediaFileExtentionUtils::CreateFile(parentUri, displayName, newUri);
1525 if (expect && (!bValid)) {
1526 EXPECT_EQ(ret, E_SUCCESS);
1527 } else {
1528 EXPECT_NE(ret, E_SUCCESS);
1529 }
1530 if (expect && (!bValid) && ret) {
1531 MEDIA_ERR_LOG("Dir: %{public}s, name: %{public}s, ret: %{public}d, suffix: %{public}c, bValid: %{public}d",
1532 parent->GetDisplayName().c_str(), displayName.c_str(), ret, static_cast<char>(i), bValid);
1533 }
1534 }
1535 }
1536
1537 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_ExtensionCheck_test_001, TestSize.Level0)
1538 {
1539 if (!MediaLibraryUnitTestUtils::IsValid()) {
1540 MEDIA_ERR_LOG("MediaLibraryDataManager invalid");
1541 exit(1);
1542 }
1543
1544 const string title = "Extention001";
1545 MediaFileExtensionCheck(g_documents, SUPPORTED_IMAGE_FORMATS_SET, title, true);
1546 MediaFileExtensionCheck(g_documents, SUPPORTED_VIDEO_FORMATS_SET, title, true);
1547 MediaFileExtensionCheck(g_documents, SUPPORTED_AUDIO_FORMATS_SET, title, true);
1548 DocumentsExtensionCheck(g_documents, title, true);
1549 SpecialCharacterExtensionCheck(g_documents, title, true);
1550
1551 MediaFileExtensionCheck(g_download, SUPPORTED_IMAGE_FORMATS_SET, title, true);
1552 MediaFileExtensionCheck(g_download, SUPPORTED_VIDEO_FORMATS_SET, title, true);
1553 MediaFileExtensionCheck(g_download, SUPPORTED_AUDIO_FORMATS_SET, title, true);
1554 DocumentsExtensionCheck(g_download, title, true);
1555 SpecialCharacterExtensionCheck(g_download, title, true);
1556 }
1557
1558 int RenameTest(const shared_ptr<FileAsset> &parent, string nameCreate, string nameRename)
1559 {
1560 Uri parentUri(parent->GetUri());
1561 Uri newUri("");
1562 Uri newUriTest("");
1563 if (mediaFileExtAbility->CreateFile(parentUri, nameCreate, newUri) != E_SUCCESS) {
1564 return -1;
1565 }
1566 int32_t ret = mediaFileExtAbility->Rename(newUri, nameRename, newUriTest);
1567 mediaFileExtAbility->Delete(newUri);
1568 return ret;
1569 }
1570
1571 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Copy_test_001, TestSize.Level0)
1572 {
1573 Uri sourceUri("");
1574 Uri parentUri(g_documents->GetUri());
1575 int32_t ret = MediaFileExtentionUtils::CreateFile(parentUri, "Rename_test_007.jpg", sourceUri);
1576 EXPECT_GT(ret, E_SUCCESS);
1577 Uri parentUriOne(g_download->GetUri());
1578 vector<CopyResult> copyResult;
1579 ret = MediaFileExtentionUtils::Copy(sourceUri, parentUriOne, copyResult, true);
1580 EXPECT_EQ(ret, E_SUCCESS);
1581 ret = MediaFileExtentionUtils::Copy(sourceUri, parentUriOne, copyResult, true);
1582 EXPECT_EQ(ret, E_SUCCESS);
1583 }
1584
1585 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Copy_test_002, TestSize.Level0)
1586 {
1587 Uri parentUri(g_documents->GetUri());
1588 string displayName = "medialib_Mkdir_test_002";
1589 Uri newUri("");
1590 int32_t ret = MediaFileExtentionUtils::Mkdir(parentUri, displayName, newUri);
1591 EXPECT_GT(ret, E_SUCCESS);
1592 Uri parentUriOne(g_download->GetUri());
1593 vector<CopyResult> copyResult;
1594 ret = MediaFileExtentionUtils::Copy(newUri, parentUriOne, copyResult, true);
1595 EXPECT_EQ(ret, E_SUCCESS);
1596 MEDIA_DEBUG_LOG("medialib_Copy_test_002 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
1597 }
1598
1599 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Copy_test_003, TestSize.Level0)
1600 {
1601 Uri parentUri(g_documents->GetUri());
1602 string displayName = "medialib_Mkdir_test_003";
1603 Uri newUri("");
1604 int32_t ret = MediaFileExtentionUtils::Mkdir(parentUri, displayName, newUri);
1605 EXPECT_GT(ret, E_SUCCESS);
1606 ret = MediaFileExtentionUtils::CreateFile(newUri, "medialib_Copy_test_003.jpg", newUri);
1607 EXPECT_GT(ret, E_SUCCESS);
1608 Uri parentUriOne(g_pictures->GetUri());
1609 vector<CopyResult> copyResult;
1610 ret = MediaFileExtentionUtils::Copy(newUri, parentUriOne, copyResult, true);
1611 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
1612 MEDIA_DEBUG_LOG("medialib_Copy_test_003 ret: %{public}d, newUri: %{public}s", ret, newUri.ToString().c_str());
1613 }
1614
1615 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Copy_test_004, TestSize.Level0)
1616 {
1617 Uri sourceUri("");
1618 Uri parentUri(g_documents->GetUri());
1619 int32_t ret = MediaFileExtentionUtils::CreateFile(parentUri, "medialib_Copy_test_004.png", sourceUri);
1620 EXPECT_GT(ret, E_SUCCESS);
1621 Uri parentUriOne(g_pictures->GetUri());
1622 vector<CopyResult> copyResult;
1623 ret = MediaFileExtentionUtils::Copy(sourceUri, parentUriOne, copyResult, true);
1624 EXPECT_EQ(ret, JS_ERR_PERMISSION_DENIED);
1625 }
1626
1627 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Copy_test_005, TestSize.Level0)
1628 {
1629 Uri sourceUri("");
1630 Uri parentUri(g_documents->GetUri());
1631 int32_t ret = MediaFileExtentionUtils::CreateFile(parentUri, "medialib_Copy_test_005.png", sourceUri);
1632 EXPECT_GT(ret, E_SUCCESS);
1633 vector<CopyResult> copyResult;
1634 ret = MediaFileExtentionUtils::Copy(sourceUri, sourceUri, copyResult, true);
1635 EXPECT_LT(ret, 0);
1636 }
1637
1638 /**
1639 * @tc.number : medialib_Rename_test_009
1640 * @tc.name : file rename function test under download
1641 * @tc.desc : Create files to invoke the Rename() interface.
1642 */
1643 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_009, TestSize.Level0)
1644 {
1645 string nameCreate = "download_test." + *SUPPORTED_IMAGE_FORMATS_SET.begin();
1646 string nameRename = "download_test." + *++SUPPORTED_IMAGE_FORMATS_SET.begin();
1647 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1648 nameRename = "download." + *SUPPORTED_AUDIO_FORMATS_SET.begin();
1649 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1650 nameRename = "&%^&." + *SUPPORTED_VIDEO_FORMATS_SET.begin();
1651 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1652 nameRename = "124.BMP";
1653 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1654 nameRename = "ABC.1234";
1655 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1656 nameRename = "asd.@@@";
1657 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1658 nameRename = "medialib_Rename_test. name";
1659 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1660 nameRename = "5678.测试";
1661 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1662 nameRename = "测试.bmp";
1663 EXPECT_EQ(RenameTest(g_download, nameCreate, nameRename), E_SUCCESS);
1664 }
1665
1666 /**
1667 * @tc.number : medialib_Rename_test_010
1668 * @tc.name : file rename function test under documents
1669 * @tc.desc : Create files to invoke the Rename() interface.
1670 */
1671 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_010, TestSize.Level0)
1672 {
1673 string nameCreate = "documents_test.gz";
1674 string nameRename = "documents_test.GZ";
1675 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1676 nameRename = "documents.1234";
1677 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1678 nameRename = "9%1.@@@";
1679 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1680 nameRename = "ABC. name";
1681 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1682 nameRename = "测试. name";
1683 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1684 nameRename = "1234.))))";
1685 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1686 }
1687
1688 /**
1689 * @tc.number : medialib_Rename_test_011
1690 * @tc.name : file rename function test under documents
1691 * @tc.desc : Create files to invoke the Rename() interface.
1692 */
1693 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_Rename_test_011, TestSize.Level0)
1694 {
1695 string nameCreate = "documents_test.gz";
1696 string nameRename = "documents_test." + *SUPPORTED_IMAGE_FORMATS_SET.begin();
1697 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1698 nameRename = "documents." + *SUPPORTED_AUDIO_FORMATS_SET.begin();
1699 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1700 nameRename = "%&$." + *SUPPORTED_VIDEO_FORMATS_SET.begin();
1701 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1702 nameRename = "ASX.BMP";
1703 EXPECT_EQ(RenameTest(g_documents, nameCreate, nameRename), E_SUCCESS);
1704 }
1705
1706 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_checkUriValid_test_001, TestSize.Level0)
1707 {
1708 bool ret = MediaFileExtentionUtils::CheckUriValid("");
1709 EXPECT_EQ(ret, false);
1710 ret = MediaFileExtentionUtils::CheckUriValid("datashare://test");
1711 EXPECT_EQ(ret, false);
1712 ret = MediaFileExtentionUtils::CheckUriValid("datashare://test/");
1713 EXPECT_EQ(ret, false);
1714 ret = MediaFileExtentionUtils::CheckUriValid("datashare://test/CheckUriValid");
1715 EXPECT_EQ(ret, false);
1716 ret = MediaFileExtentionUtils::CheckUriValid("datashare://test/CheckUriValid1");
1717 EXPECT_EQ(ret, false);
1718 ret = MediaFileExtentionUtils::CheckUriValid("datashare://media/1");
1719 EXPECT_EQ(ret, true);
1720 }
1721
1722 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_checkDistributedUri_test_001, TestSize.Level0)
1723 {
1724 bool ret = MediaFileExtentionUtils::CheckDistributedUri("");
1725 EXPECT_EQ(ret, true);
1726 ret = MediaFileExtentionUtils::CheckDistributedUri("datashare://test/CheckDistributedUri");
1727 EXPECT_EQ(ret, false);
1728 }
1729
1730 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_checkUriSupport_test_001, TestSize.Level0)
1731 {
1732 int32_t ret = MediaFileExtentionUtils::CheckUriSupport("");
1733 EXPECT_EQ(ret, E_URI_INVALID);
1734 ret = MediaFileExtentionUtils::CheckUriSupport("datashare://media/1");
1735 EXPECT_EQ(ret, E_DISTIBUTED_URI_NO_SUPPORT);
1736 ret = MediaFileExtentionUtils::CheckUriSupport("datashare:///media/1");
1737 EXPECT_EQ(ret, E_SUCCESS);
1738 }
1739
1740 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_getResultSetFromDb_test_001, TestSize.Level0)
1741 {
1742 string value = "getResultSetFromDb";
1743 vector<string> columns;
1744 auto queryResultSet = MediaFileExtentionUtils::GetResultSetFromDb(MEDIA_DATA_DB_URI, value, columns);
1745 EXPECT_EQ(queryResultSet, nullptr);
1746 string field = "/storage/cloud/files";
1747 queryResultSet = MediaFileExtentionUtils::GetResultSetFromDb(MEDIA_DATA_DB_URI, value, columns);
1748 EXPECT_EQ(queryResultSet, nullptr);
1749 }
1750
1751 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_isFileExistInDb_test_001, TestSize.Level0)
1752 {
1753 string path = "datashare://1";
1754 bool ret = MediaFileExtentionUtils::IsFileExistInDb(path);
1755 EXPECT_EQ(ret, false);
1756 string pathTest = "";
1757 ret = MediaFileExtentionUtils::IsFileExistInDb(pathTest);
1758 EXPECT_EQ(ret, true);
1759 }
1760
1761 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_resolveUri_test_001, TestSize.Level0)
1762 {
1763 FileInfo fileInfo;
1764 MediaFileUriType uriType;
1765 fileInfo.uri = "resolveUri";
1766 int32_t ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1767 EXPECT_EQ(ret, E_INVALID_URI);
1768 fileInfo.uri = "datashare://";
1769 ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1770 EXPECT_EQ(ret, E_INVALID_URI);
1771 fileInfo.uri = "datashare:///media";
1772 ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1773 EXPECT_EQ(ret, E_INVALID_URI);
1774 fileInfo.uri = "datashare:///media/root";
1775 ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1776 EXPECT_EQ(ret, E_SUCCESS);
1777 fileInfo.uri = "datashare:///media/roottest";
1778 ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1779 EXPECT_EQ(ret, E_INVALID_URI);
1780 fileInfo.uri = "datashare:///media/file";
1781 ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1782 EXPECT_EQ(ret, E_SUCCESS);
1783 fileInfo.uri = "datashare:///media/1";
1784 ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1785 EXPECT_EQ(ret, E_SUCCESS);
1786 fileInfo.uri = "datashare://media/test";
1787 ret = MediaFileExtentionUtils::ResolveUri(fileInfo, uriType);
1788 EXPECT_EQ(ret, E_INVALID_URI);
1789 }
1790
1791 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_checkValidDirName_test_001, TestSize.Level0)
1792 {
1793 string displayName = "";
1794 bool ret = MediaFileExtentionUtils::CheckValidDirName(displayName);
1795 EXPECT_EQ(ret, false);
1796 string displayNameTest = "Camera/";
1797 ret = MediaFileExtentionUtils::CheckValidDirName(displayNameTest);
1798 EXPECT_EQ(ret, true);
1799 }
1800
1801 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_checkMkdirValid_test_001, TestSize.Level0)
1802 {
1803 MediaFileUriType uriType = URI_FILE_ROOT;
1804 string parentUriStr = "datashare:///1";
1805 string displayName = "Camera/";
1806 int32_t ret = MediaFileExtentionUtils::CheckMkdirValid(uriType, parentUriStr, displayName);
1807 EXPECT_EQ(ret, E_INVALID_DISPLAY_NAME);
1808 parentUriStr = "datashare://test/";
1809 ret = MediaFileExtentionUtils::CheckMkdirValid(uriType, parentUriStr, displayName);
1810 EXPECT_EQ(ret, E_DISTIBUTED_URI_NO_SUPPORT);
1811 parentUriStr = "datashare:///test/";
1812 displayName = "Camera";
1813 ret = MediaFileExtentionUtils::CheckMkdirValid(uriType, parentUriStr, displayName);
1814 EXPECT_EQ(ret, E_SUCCESS);
1815
1816 uriType = URI_MEDIA_ROOT;
1817 ret = MediaFileExtentionUtils::CheckMkdirValid(uriType, parentUriStr, displayName);
1818 EXPECT_EQ(ret, E_URI_INVALID);
1819 parentUriStr = "datashare:///media/1";
1820 displayName = "Camera/";
1821 ret = MediaFileExtentionUtils::CheckMkdirValid(uriType, parentUriStr, displayName);
1822 EXPECT_EQ(ret, E_INVALID_DISPLAY_NAME);
1823 displayName = "test";
1824 ret = MediaFileExtentionUtils::CheckMkdirValid(uriType, parentUriStr, displayName);
1825 EXPECT_EQ(ret, E_SUCCESS);
1826 }
1827
1828 HWTEST_F(MediaLibraryFileExtUnitTest, medialib_getAlbumRelativePathFromDB_test_001, TestSize.Level0)
1829 {
1830 string selectUri = "datashare:///media/file";
1831 string relativePath = "/storage/cloud/files";
1832 bool ret = MediaFileExtentionUtils::GetAlbumRelativePathFromDB(selectUri, relativePath);
1833 EXPECT_EQ(ret, false);
1834 }
1835 } // namespace Media
1836 } // namespace OHOS
1837
