1 /*
2 * Copyright (C) 2021 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_unit_test.h"
17 #include "media_log.h"
18
19 using namespace std;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace Media {
24 IMediaLibraryClient* g_mediaLibClientInstance = nullptr;
25
SetUpTestCase(void)26 void MediaLibraryUnitTest::SetUpTestCase(void)
27 {
28 g_mediaLibClientInstance = IMediaLibraryClient::GetMediaLibraryClientInstance();
29 }
30
TearDownTestCase(void)31 void MediaLibraryUnitTest::TearDownTestCase(void)
32 {
33 string albumUri;
34 AlbumAsset albumAsset;
35 AssetType assetType = ASSET_IMAGEALBUM;
36
37 albumUri = "/storage/media/local/files/gtest";
38 if (g_mediaLibClientInstance != nullptr) {
39 (void)g_mediaLibClientInstance->DeleteMediaAlbumAsset(assetType, albumAsset, albumUri);
40 }
41
42 g_mediaLibClientInstance = nullptr;
43 }
44
45 /* SetUp:Execute before each test case */
SetUp()46 void MediaLibraryUnitTest::SetUp() {}
47
TearDown(void)48 void MediaLibraryUnitTest::TearDown(void) {}
49
50 /*
51 * Feature: MediaLibrary
52 * Function: CreateMediaAsset
53 * SubFunction: NA
54 * FunctionPoints: NA
55 * EnvConditions: NA
56 * CaseDescription: Create media audio asset in requested directory.
57 */
58 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAsset_testlevel0_001, TestSize.Level0)
59 {
60 bool errCode = false;
61 MediaAsset mediaAsset;
62 AssetType assetType = ASSET_AUDIO;
63 mediaAsset.name_ = "test_001_audio.mp3";
64 mediaAsset.albumName_ = "gtest/001/audio";
65 if (g_mediaLibClientInstance != nullptr) {
66 errCode = g_mediaLibClientInstance->CreateMediaAsset(assetType, mediaAsset);
67 }
68 EXPECT_NE(errCode, false);
69 }
70
71 /*
72 * Feature: MediaLibrary
73 * Function: CreateMediaAsset
74 * SubFunction: NA
75 * FunctionPoints: NA
76 * EnvConditions: NA
77 * CaseDescription: Create media audio asset in ROOT_DIR=/storage/media/local/files directory.
78 */
79 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAsset_test_002, TestSize.Level1)
80 {
81 bool errCode = false;
82 MediaAsset mediaAsset;
83 AssetType assetType = ASSET_AUDIO;
84
85 mediaAsset.name_ = "gtest_002_audio.mp3";
86 mediaAsset.albumName_ = "";
87 if (g_mediaLibClientInstance != nullptr) {
88 errCode = g_mediaLibClientInstance->CreateMediaAsset(assetType, mediaAsset);
89
90 // clearing the file created
91 mediaAsset.uri_ = "/storage/media/local/files/gtest_002_audio.mp3";
92 (void)g_mediaLibClientInstance->DeleteMediaAsset(assetType, mediaAsset);
93 }
94 EXPECT_NE(errCode, false);
95 }
96 /*
97 * Feature: MediaLibrary
98 * Function: GetAudioAssets
99 * SubFunction: NA
100 * FunctionPoints: NA
101 * EnvConditions: NA
102 * CaseDescription: Get audio assets prsent in particalar directory and subdirectories.
103 */
104 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetAudioAssets_testlevel0_001, TestSize.Level0)
105 {
106 vector<unique_ptr<AudioAsset>> audioAssetList;
107 unsigned int size = 0;
108 string dirPath = "gtest/001/audio";
109 vector<string> selectionArgs;
110 struct stat statInfo {};
111 string dirPathCheck = "/storage/media/local/files/" + dirPath;
112
113 if (stat(dirPathCheck.c_str(), &statInfo) == 0) {
114 if (statInfo.st_mode & S_IFDIR) {
115 if (g_mediaLibClientInstance != nullptr) {
116 audioAssetList = g_mediaLibClientInstance->GetAudioAssets(dirPath, selectionArgs);
117 }
118 }
119 }
120 EXPECT_NE(audioAssetList.size(), size);
121 }
122
123 /*
124 * Feature: MediaLibrary
125 * Function: GetAudioAssets
126 * SubFunction: NA
127 * FunctionPoints: NA
128 * EnvConditions: NA
129 * CaseDescription: Get audio assets from ROOT_DIR=/storage/media/local/files directory and subdirectories.
130 */
131 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetAudioAssets_test_002, TestSize.Level1)
132 {
133 vector<unique_ptr<AudioAsset>> audioAssetList;
134 unsigned int size = 0;
135 string dirPath = ""; // ROOT_DIR
136 vector<string> selectionArgs;
137
138 if (g_mediaLibClientInstance != nullptr) {
139 audioAssetList = g_mediaLibClientInstance->GetAudioAssets(dirPath, selectionArgs);
140 }
141 EXPECT_NE(audioAssetList.size(), size);
142 }
143
144 /*
145 * Feature: MediaLibrary
146 * Function: CreateMediaAsset
147 * SubFunction: NA
148 * FunctionPoints: NA
149 * EnvConditions: NA
150 * CaseDescription: Create media video asset in requested directory.
151 */
152 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAsset_testlevel0_003, TestSize.Level0)
153 {
154 bool errCode = false;
155 MediaAsset mediaAsset;
156 AssetType assetType = ASSET_VIDEO;
157
158 mediaAsset.name_ = "test_002_video.mp4";
159 mediaAsset.albumName_ = "gtest/002/video";
160 if (g_mediaLibClientInstance != nullptr) {
161 errCode = g_mediaLibClientInstance->CreateMediaAsset(assetType, mediaAsset);
162 }
163 EXPECT_NE(errCode, false);
164 }
165
166 /*
167 * Feature: MediaLibrary
168 * Function: CreateMediaAsset
169 * SubFunction: NA
170 * FunctionPoints: NA
171 * EnvConditions: NA
172 * CaseDescription: Create media video sset in ROOT_DIR=/storage/media/local/files directory.
173 */
174 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAsset_test_004, TestSize.Level1)
175 {
176 bool errCode = false;
177 MediaAsset mediaAsset;
178 AssetType assetType = ASSET_VIDEO;
179
180 mediaAsset.name_ = "test_002_video.mp4";
181 mediaAsset.albumName_ = "";
182 if (g_mediaLibClientInstance != nullptr) {
183 errCode = g_mediaLibClientInstance->CreateMediaAsset(assetType, mediaAsset);
184
185 // clearing the file created
186 mediaAsset.uri_ = "/storage/media/local/files/test_002_video.mp4";
187 (void)g_mediaLibClientInstance->DeleteMediaAsset(assetType, mediaAsset);
188 }
189 EXPECT_NE(errCode, false);
190 }
191
192 /*
193 * Feature: MediaLibrary
194 * Function: GetVideoAssets
195 * SubFunction: NA
196 * FunctionPoints: NA
197 * EnvConditions: NA
198 * CaseDescription: Get video assets present in particalar directory and subdirectories.
199 */
200 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetVideoAssets_testlevel0_001, TestSize.Level0)
201 {
202 vector<unique_ptr<VideoAsset>> videoAssetList;
203 unsigned int size = 0;
204 string dirPath = "gtest/002/video";
205 vector<string> selectionArgs;
206 struct stat statInfo {};
207 string dirPathCheck = "/storage/media/local/files/" + dirPath;
208
209 if (stat(dirPathCheck.c_str(), &statInfo) == 0) {
210 if (statInfo.st_mode & S_IFDIR) {
211 if (g_mediaLibClientInstance != nullptr) {
212 videoAssetList = g_mediaLibClientInstance->GetVideoAssets(dirPath, selectionArgs);
213 }
214 }
215 }
216 EXPECT_NE(videoAssetList.size(), size);
217 }
218
219 /*
220 * Feature: MediaLibrary
221 * Function: GetVideoAssets
222 * SubFunction: NA
223 * FunctionPoints: NA
224 * EnvConditions: NA
225 * CaseDescription: Get video assets from ROOT_DIR=/storage/media/local/files directory and subdirectories.
226 */
227 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetVideoAssets_test_002, TestSize.Level1)
228 {
229 vector<unique_ptr<VideoAsset>> videoAssetList;
230 unsigned int size = 0;
231 string dirPath = "";
232 vector<string> selectionArgs;
233
234 if (g_mediaLibClientInstance != nullptr) {
235 videoAssetList = g_mediaLibClientInstance->GetVideoAssets(dirPath, selectionArgs);
236 }
237 EXPECT_NE(videoAssetList.size(), size);
238 }
239
240 /*
241 * Feature: MediaLibrary
242 * Function: CreateMediaAsset
243 * SubFunction: NA
244 * FunctionPoints: NA
245 * EnvConditions: NA
246 * CaseDescription: Create media image asset in requested directory.
247 */
248 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAsset_testlevel0_005, TestSize.Level0)
249 {
250 bool errCode = false;
251 MediaAsset mediaAsset;
252 AssetType assetType = ASSET_IMAGE;
253
254 mediaAsset.name_ = "test_003_image.jpg";
255 mediaAsset.albumName_ = "gtest/003/image";
256 if (g_mediaLibClientInstance != nullptr) {
257 errCode = g_mediaLibClientInstance->CreateMediaAsset(assetType, mediaAsset);
258 }
259 EXPECT_NE(errCode, false);
260 }
261
262 /*
263 * Feature: MediaLibrary
264 * Function: CreateMediaAsset
265 * SubFunction: NA
266 * FunctionPoints: NA
267 * EnvConditions: NA
268 * CaseDescription: Create media image asset in ROOT_DIR=/storage/media/local/files directory.
269 */
270 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAsset_test_006, TestSize.Level1)
271 {
272 bool errCode = false;
273 MediaAsset mediaAsset;
274 AssetType assetType = ASSET_IMAGE;
275
276 mediaAsset.name_ = "test_003_image.jpg";
277 mediaAsset.albumName_ = "";
278 if (g_mediaLibClientInstance != nullptr) {
279 errCode = g_mediaLibClientInstance->CreateMediaAsset(assetType, mediaAsset);
280
281 // clearing the file created
282 mediaAsset.uri_ = "/storage/media/local/files/test_003_image.jpg";
283 (void)g_mediaLibClientInstance->DeleteMediaAsset(assetType, mediaAsset);
284 }
285 EXPECT_NE(errCode, false);
286 }
287
288 /*
289 * Feature: MediaLibrary
290 * Function: CreateMediaAsset
291 * SubFunction: NA
292 * FunctionPoints: NA
293 * EnvConditions: NA
294 * CaseDescription: Create existing media asset in requested directory.
295 */
296 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAsset_test_007, TestSize.Level1)
297 {
298 bool errCode = true;
299 MediaAsset mediaAsset;
300 AssetType assetType = ASSET_IMAGE;
301 // create existing file
302 mediaAsset.name_ = "test_003_image.jpg";
303 mediaAsset.albumName_ = "gtest/003/image";
304 if (g_mediaLibClientInstance != nullptr) {
305 errCode = g_mediaLibClientInstance->CreateMediaAsset(assetType, mediaAsset);
306 }
307 EXPECT_EQ(errCode, false);
308 }
309
310 /*
311 * Feature: MediaLibrary
312 * Function: GetImageAssets
313 * SubFunction: NA
314 * FunctionPoints: NA
315 * EnvConditions: NA
316 * CaseDescription: Get image assets present in particalar directory and subdirectories.
317 */
318 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetImageAssets_testlevel0_001, TestSize.Level0)
319 {
320 vector<unique_ptr<ImageAsset>> imageAssetList;
321 unsigned int size = 0;
322 string dirPath = "gtest/003/image";
323 vector<string> selectionArgs;
324 struct stat statInfo {};
325 string dirPathCheck = "/storage/media/local/files/" + dirPath;
326
327 if (stat(dirPathCheck.c_str(), &statInfo) == 0) {
328 if (statInfo.st_mode & S_IFDIR) {
329 if (g_mediaLibClientInstance != nullptr) {
330 imageAssetList = g_mediaLibClientInstance->GetImageAssets(dirPath, selectionArgs);
331 }
332 }
333 }
334 EXPECT_NE(imageAssetList.size(), size);
335 }
336
337 /*
338 * Feature: MediaLibrary
339 * Function: GetImageAssets
340 * SubFunction: NA
341 * FunctionPoints: NA
342 * EnvConditions: NA
343 * CaseDescription: Get image assets from ROOT_DIR=/storage/media/local/files directory and subdirectories.
344 */
345 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetImageAssets_test_002, TestSize.Level1)
346 {
347 vector<unique_ptr<ImageAsset>> imageAssetList;
348 unsigned int size = 0;
349 string dirPath = "";
350 vector<string> selectionArgs;
351
352 if (g_mediaLibClientInstance != nullptr) {
353 imageAssetList = g_mediaLibClientInstance->GetImageAssets(dirPath, selectionArgs);
354 }
355 EXPECT_NE(imageAssetList.size(), size);
356 }
357
358 /*
359 * Feature: MediaLibrary
360 * Function: GetMediaAssets
361 * SubFunction: NA
362 * FunctionPoints: NA
363 * EnvConditions: NA
364 * CaseDescription: Get media assets present in particalar directory and subdirectories.
365 */
366 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetMediaAssets_testlevel0_001, TestSize.Level0)
367 {
368 vector<unique_ptr<MediaAsset>> mediaAssetList;
369 unsigned int size = 0;
370 string dirPath = "gtest/003/image";
371 vector<string> selectionArgs;
372 struct stat statInfo {};
373 string dirPathCheck = "/storage/media/local/files/" + dirPath;
374
375 if (stat(dirPathCheck.c_str(), &statInfo) == 0) {
376 if (statInfo.st_mode & S_IFDIR) {
377 if (g_mediaLibClientInstance != nullptr) {
378 mediaAssetList = g_mediaLibClientInstance->GetMediaAssets(dirPath, selectionArgs);
379 }
380 }
381 }
382 EXPECT_NE(mediaAssetList.size(), size);
383 }
384
385 /*
386 * Feature: MediaLibrary
387 * Function: GetMediaAssets
388 * SubFunction: NA
389 * FunctionPoints: NA
390 * EnvConditions: NA
391 * CaseDescription: Get media assets from ROOT_DIR=/storage/media/local/files directory and subdirectories.
392 */
393 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetMediaAssets_test_002, TestSize.Level1)
394 {
395 vector<unique_ptr<MediaAsset>> mediaAssetList;
396 unsigned int size = 0;
397 string dirPath = "";
398 vector<string> selectionArgs;
399
400 if (g_mediaLibClientInstance != nullptr) {
401 mediaAssetList = g_mediaLibClientInstance->GetMediaAssets(dirPath, selectionArgs);
402 }
403 EXPECT_NE(mediaAssetList.size(), size);
404 }
405
406 /*
407 * Feature: MediaLibrary
408 * Function: GetImageAlbumAssets
409 * SubFunction: NA
410 * FunctionPoints: NA
411 * EnvConditions: NA
412 * CaseDescription: Get image media assets present in particalar directory and subdirectories.
413 */
414 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetIMageAlbumAssets_testlevel0_001, TestSize.Level0)
415 {
416 vector<unique_ptr<AlbumAsset>> albumAssetList;
417 unsigned int size = 0;
418 string dirPath = "gtest/003";
419 vector<string> selectionArgs;
420 struct stat statInfo {};
421 string dirPathCheck = "/storage/media/local/files/" + dirPath;
422
423 if (stat(dirPathCheck.c_str(), &statInfo) == 0) {
424 if (statInfo.st_mode & S_IFDIR) {
425 if (g_mediaLibClientInstance != nullptr) {
426 albumAssetList = g_mediaLibClientInstance->GetImageAlbumAssets(dirPath, selectionArgs);
427 }
428 }
429 }
430 EXPECT_NE(albumAssetList.size(), size);
431 }
432
433 /*
434 * Feature: MediaLibrary
435 * Function: GetImageAlbumAssets
436 * SubFunction: NA
437 * FunctionPoints: NA
438 * EnvConditions: NA
439 * CaseDescription: Get image album assets from ROOT_DIR=/storage/media/local/files/ directory and subdirectories.
440 */
441 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetImageAlbumAssets_test_002, TestSize.Level1)
442 {
443 bool errCode = false;
444 AlbumAsset albumAsset;
445 AssetType assetType = ASSET_IMAGEALBUM;
446
447 albumAsset.SetAlbumName("crtalbum002");
448 if (g_mediaLibClientInstance != nullptr) {
449 errCode = g_mediaLibClientInstance->CreateMediaAlbumAsset(assetType, albumAsset);
450 }
451 EXPECT_NE(errCode, false);
452
453 vector<unique_ptr<AlbumAsset>> albumAssetList;
454 unsigned int size = 0;
455 string dirPath = "";
456 vector<string> selectionArgs;
457
458 if (g_mediaLibClientInstance != nullptr) {
459 albumAssetList = g_mediaLibClientInstance->GetImageAlbumAssets(dirPath, selectionArgs);
460 }
461 EXPECT_NE(albumAssetList.size(), size);
462
463 errCode = false;
464 string albumUri;
465
466 // delete the empty album
467 albumUri = "/storage/media/local/files/crtalbum002";
468 if (g_mediaLibClientInstance != nullptr) {
469 errCode = g_mediaLibClientInstance->DeleteMediaAlbumAsset(assetType, albumAsset, albumUri);
470 }
471 EXPECT_NE(errCode, false);
472 }
473
474 /*
475 * Feature: MediaLibrary
476 * Function: GetVideoAlbumAssets
477 * SubFunction: NA
478 * FunctionPoints: NA
479 * EnvConditions: NA
480 * CaseDescription: Get video media assets present in particalar directory and subdirectories.
481 */
482 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetVideoAlbumAssets_testlevel0_003, TestSize.Level0)
483 {
484 vector<unique_ptr<AlbumAsset>> albumAssetList;
485 unsigned int size = 0;
486 string dirPath = "gtest/002";
487 vector<string> selectionArgs;
488 struct stat statInfo {};
489 string dirPathCheck = "/storage/media/local/files/" + dirPath;
490
491 if (stat(dirPathCheck.c_str(), &statInfo) == 0) {
492 if (statInfo.st_mode & S_IFDIR) {
493 if (g_mediaLibClientInstance != nullptr) {
494 albumAssetList = g_mediaLibClientInstance->GetVideoAlbumAssets(dirPath, selectionArgs);
495 }
496 }
497 }
498 EXPECT_NE(albumAssetList.size(), size);
499 }
500
501 /*
502 * Feature: MediaLibrary
503 * Function: GetVideoAlbumAssets
504 * SubFunction: NA
505 * FunctionPoints: NA
506 * EnvConditions: NA
507 * CaseDescription: Get video album assets from ROOT_DIR=/storage/media/local/files directory and subdirectories.
508 */
509 HWTEST_F(MediaLibraryUnitTest, medialibrary_GetVideoAlbumAssets_test_004, TestSize.Level1)
510 {
511 vector<unique_ptr<AlbumAsset>> albumAssetList;
512 unsigned int size = 0;
513 string dirPath = "";
514 vector<string> selectionArgs;
515
516 if (g_mediaLibClientInstance != nullptr) {
517 albumAssetList = g_mediaLibClientInstance->GetVideoAlbumAssets(dirPath, selectionArgs);
518 }
519 EXPECT_EQ(albumAssetList.size(), size);
520 }
521
522 /*
523 * Feature: MediaLibrary
524 * Function: ModifyMediaAsset
525 * SubFunction: NA
526 * FunctionPoints: NA
527 * EnvConditions: NA
528 * CaseDescription: Modify media audio asset in requested directory.
529 */
530 HWTEST_F(MediaLibraryUnitTest, medialibrary_ModifyMediaAsset_testlevel0_001, TestSize.Level0)
531 {
532 bool errCode = false;
533 MediaAsset srcMediaAsset;
534 MediaAsset dstMediaAsset;
535 AssetType assetType = ASSET_AUDIO;
536
537 srcMediaAsset.name_ = "test_001_audio.mp3";
538 srcMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio/test_001_audio.mp3";
539 dstMediaAsset.name_ = "test_001_audio_modify.mp3";
540 dstMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio/test_001_audio.mp3";
541 if (g_mediaLibClientInstance != nullptr) {
542 errCode = g_mediaLibClientInstance->ModifyMediaAsset(assetType, srcMediaAsset, dstMediaAsset);
543 }
544 EXPECT_NE(errCode, false);
545 }
546
547 /*
548 * Feature: MediaLibrary
549 * Function: ModifyMediaAsset
550 * SubFunction: NA
551 * FunctionPoints: NA
552 * EnvConditions: NA
553 * CaseDescription: Modify media audio mp3 file to wav in requested directory.
554 */
555 HWTEST_F(MediaLibraryUnitTest, medialibrary_ModifyMediaAsset_test_002, TestSize.Level1)
556 {
557 bool errCode = true;
558 MediaAsset srcMediaAsset;
559 MediaAsset dstMediaAsset;
560 AssetType assetType = ASSET_AUDIO;
561
562 srcMediaAsset.name_ = "test_002_audio.mp3";
563 srcMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio/test_002_audio.mp3";
564 dstMediaAsset.name_ = "test_002_audio_modify.wav";
565 dstMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio/test_002_audio.mp3";
566 if (g_mediaLibClientInstance != nullptr) {
567 errCode = g_mediaLibClientInstance->ModifyMediaAsset(assetType, srcMediaAsset, dstMediaAsset);
568 }
569 EXPECT_EQ(errCode, false);
570 }
571
572 /*
573 * Feature: MediaLibrary
574 * Function: ModifyMediaAsset
575 * SubFunction: NA
576 * FunctionPoints: NA
577 * EnvConditions: NA
578 * CaseDescription: Modify media audio asset in requested non existing directory.
579 */
580 HWTEST_F(MediaLibraryUnitTest, medialibrary_ModifyMediaAsset_test_003, TestSize.Level1)
581 {
582 bool errCode = false;
583 MediaAsset srcMediaAsset;
584 MediaAsset dstMediaAsset;
585 AssetType assetType = ASSET_AUDIO;
586
587 srcMediaAsset.name_ = "test_002_audio.mp3";
588 srcMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio_nofile/test_002_audio.mp3";
589 dstMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio_nofile/test_002_audio.mp3";
590 dstMediaAsset.name_ = "test_002_audio_modify.mp3";
591 if (g_mediaLibClientInstance != nullptr) {
592 errCode = g_mediaLibClientInstance->ModifyMediaAsset(assetType, srcMediaAsset, dstMediaAsset);
593 }
594 EXPECT_EQ(errCode, false);
595 }
596
597 /*
598 * Feature: MediaLibrary
599 * Function: CopyMediaAsset
600 * SubFunction: NA
601 * FunctionPoints: NA
602 * EnvConditions: NA
603 * CaseDescription: copy media asset to requested new directory, which gets created.
604 */
605 HWTEST_F(MediaLibraryUnitTest, medialibrary_CopyMediaAsset_testlevel0_001, TestSize.Level0)
606 {
607 bool errCode = false;
608 MediaAsset srcMediaAsset;
609 MediaAsset dstMediaAsset;
610 AssetType assetType = ASSET_AUDIO;
611 // copy to requested albumName
612 srcMediaAsset.name_ = "test_001_audio_modify.mp3";
613 srcMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio/test_001_audio_modify.mp3";
614 dstMediaAsset.albumName_ = "gtest/001/copyaudio";
615 if (g_mediaLibClientInstance != nullptr) {
616 errCode = g_mediaLibClientInstance->CopyMediaAsset(assetType, srcMediaAsset, dstMediaAsset);
617 }
618 EXPECT_NE(errCode, false);
619 }
620
621 /*
622 * Feature: MediaLibrary
623 * Function: CopyMediaAsset
624 * SubFunction: NA
625 * FunctionPoints: NA
626 * EnvConditions: NA
627 * CaseDescription: copy media asset to requested non existing directory.
628 */
629 HWTEST_F(MediaLibraryUnitTest, medialibrary_CopyMediaAsset_testlevel0_002, TestSize.Level0)
630 {
631 bool errCode = false;
632 MediaAsset srcMediaAsset;
633 MediaAsset dstMediaAsset;
634 AssetType assetType = ASSET_IMAGE;
635 // create and Copy to requested albumName
636 srcMediaAsset.name_ = "test_003_image.jpg";
637 srcMediaAsset.uri_ = "/storage/media/local/files/gtest/003/image/test_003_image.jpg";
638 dstMediaAsset.albumName_ = "gtest/copyjpg/001/image";
639 if (g_mediaLibClientInstance != nullptr) {
640 errCode = g_mediaLibClientInstance->CopyMediaAsset(assetType, srcMediaAsset, dstMediaAsset);
641 }
642 EXPECT_NE(errCode, false);
643 }
644
645 /*
646 * Feature: MediaLibrary
647 * Function: CopyMediaAsset
648 * SubFunction: NA
649 * FunctionPoints: NA
650 * EnvConditions: NA
651 * CaseDescription: copy media asset to ROOT_DIR=/storage/media/local/files directory.
652 */
653 HWTEST_F(MediaLibraryUnitTest, medialibrary_CopyMediaAsset_test_003, TestSize.Level1)
654 {
655 bool errCode = false;
656 MediaAsset srcMediaAsset;
657 MediaAsset dstMediaAsset;
658 AssetType assetType = ASSET_AUDIO;
659 // copy to ROOT_DIR
660 srcMediaAsset.name_ = "test_001_audio_modify.mp3";
661 srcMediaAsset.uri_ = "/storage/media/local/files/gtest/001/copyaudio/test_001_audio_modify.mp3";
662 dstMediaAsset.albumName_ = "";
663 if (g_mediaLibClientInstance != nullptr) {
664 errCode = g_mediaLibClientInstance->CopyMediaAsset(assetType, srcMediaAsset, dstMediaAsset);
665 }
666 EXPECT_EQ(errCode, false);
667 }
668
669 /*
670 * Feature: MediaLibrary
671 * Function: CopyMediaAsset
672 * SubFunction: NA
673 * FunctionPoints: NA
674 * EnvConditions: NA
675 * CaseDescription: copy media asset in requested directory without source file name .
676 */
677 HWTEST_F(MediaLibraryUnitTest, medialibrary_CopyMediaAsset_test_004, TestSize.Level1)
678 {
679 bool errCode = false;
680 MediaAsset srcMediaAsset;
681 MediaAsset dstMediaAsset;
682 AssetType assetType = ASSET_AUDIO;
683
684 srcMediaAsset.name_ = "";
685 srcMediaAsset.uri_ = "/storage/media/local/files/gtest/001/audio/test_fail.mp3";
686 dstMediaAsset.albumName_ = "";
687 if (g_mediaLibClientInstance != nullptr) {
688 errCode = g_mediaLibClientInstance->CopyMediaAsset(assetType, srcMediaAsset, dstMediaAsset);
689 }
690 EXPECT_EQ(errCode, false);
691 }
692
693 /*
694 * Feature: MediaLibrary
695 * Function: DeleteMediaAsset
696 * SubFunction: NA
697 * FunctionPoints: NA
698 * EnvConditions: NA
699 * CaseDescription: Delete media audio asset from requested directory.
700 */
701 HWTEST_F(MediaLibraryUnitTest, medialibrary_DeleteMediaAsset_testlevel0_001, TestSize.Level0)
702 {
703 bool errCode = false;
704 MediaAsset mediaAsset;
705 AssetType assetType = ASSET_AUDIO;
706
707 mediaAsset.name_ = "test_001_audio_modify.mp3";
708 mediaAsset.uri_ = "/storage/media/local/files/gtest/001/copyaudio/test_001_audio_modify.mp3";
709 if (g_mediaLibClientInstance != nullptr) {
710 errCode = g_mediaLibClientInstance->DeleteMediaAsset(assetType, mediaAsset);
711 }
712 EXPECT_NE(errCode, false);
713 }
714
715 /*
716 * Feature: MediaLibrary
717 * Function: DeleteMediaAsset
718 * SubFunction: NA
719 * FunctionPoints: NA
720 * EnvConditions: NA
721 * CaseDescription: Delete media video asset in requested directory.
722 */
723 HWTEST_F(MediaLibraryUnitTest, medialibrary_DeleteMediaAsset_testlevel0_002, TestSize.Level0)
724 {
725 bool errCode = false;
726 MediaAsset mediaAsset;
727 AssetType assetType = ASSET_VIDEO;
728
729 mediaAsset.name_ = "test_002_video.mp4";
730 mediaAsset.uri_ = "/storage/media/local/files/gtest/002/video/test_002_video.mp4";
731 if (g_mediaLibClientInstance != nullptr) {
732 errCode = g_mediaLibClientInstance->DeleteMediaAsset(assetType, mediaAsset);
733 }
734 EXPECT_NE(errCode, false);
735 }
736
737 /*
738 * Feature: MediaLibrary
739 * Function: DeleteMediaAsset
740 * SubFunction: NA
741 * FunctionPoints: NA
742 * EnvConditions: NA
743 * CaseDescription: Create media image asset in requested directory.
744 */
745 HWTEST_F(MediaLibraryUnitTest, medialibrary_DeleteMediaAsset_testlevel0_003, TestSize.Level0)
746 {
747 bool errCode = false;
748 MediaAsset mediaAsset;
749 AssetType assetType = ASSET_IMAGE;
750
751 mediaAsset.name_ = "test_003_image.jpg";
752 mediaAsset.uri_ = "/storage/media/local/files/gtest/003/image/test_003_image.jpg";
753 if (g_mediaLibClientInstance != nullptr) {
754 errCode = g_mediaLibClientInstance->DeleteMediaAsset(assetType, mediaAsset);
755 }
756 EXPECT_NE(errCode, false);
757 }
758
759 /*
760 * Feature: MediaLibrary
761 * Function: DeleteMediaAsset
762 * SubFunction: NA
763 * FunctionPoints: NA
764 * EnvConditions: NA
765 * CaseDescription: Delete media asset from requested empty directory path
766 */
767 HWTEST_F(MediaLibraryUnitTest, medialibrary_DeleteMediaAsset_test_004, TestSize.Level1)
768 {
769 bool errCode = true;
770 MediaAsset mediaAsset;
771 AssetType assetType = ASSET_AUDIO;
772
773 mediaAsset.name_ = "";
774 mediaAsset.uri_ = "";
775 if (g_mediaLibClientInstance != nullptr) {
776 errCode = g_mediaLibClientInstance->DeleteMediaAsset(assetType, mediaAsset);
777 }
778 EXPECT_EQ(errCode, false);
779 }
780
781 /*
782 * Feature: MediaLibrary
783 * Function: CreateMediaAlbumAsset
784 * SubFunction: NA
785 * FunctionPoints: NA
786 * EnvConditions: NA
787 * CaseDescription: Create album asset in requested directory.
788 */
789 HWTEST_F(MediaLibraryUnitTest, medialibrary_CreateMediaAlbumAsset_testlevel0_001, TestSize.Level0)
790 {
791 bool errCode = false;
792 AlbumAsset albumAsset;
793 AssetType assetType = ASSET_GENERIC_ALBUM;
794
795 albumAsset.SetAlbumName("gtest/crtalbum001");
796 if (g_mediaLibClientInstance != nullptr) {
797 errCode = g_mediaLibClientInstance->CreateMediaAlbumAsset(assetType, albumAsset);
798 }
799 EXPECT_NE(errCode, false);
800 }
801
802 /*
803 * Feature: MediaLibrary
804 * Function: ModifyMediaAlbumAsset
805 * SubFunction: NA
806 * FunctionPoints: NA
807 * EnvConditions: NA
808 * CaseDescription: Modify image album asset from requested directory.
809 */
810 HWTEST_F(MediaLibraryUnitTest, medialibrary_ModifyMediaAlbumAsset_testlevel0_001, TestSize.Level0)
811 {
812 bool errCode = false;
813 AlbumAsset srcAlbumAsset;
814 AlbumAsset dstAlbumAsset;
815 string albumUri;
816 AssetType assetType = ASSET_IMAGEALBUM;
817
818 srcAlbumAsset.SetAlbumName("gtest/copyjpg/001/image");
819 dstAlbumAsset.SetAlbumName("modify_image001");
820 albumUri = "/storage/media/local/files/gtest/copyjpg/001/image";
821 if (g_mediaLibClientInstance != nullptr) {
822 errCode = g_mediaLibClientInstance->ModifyMediaAlbumAsset(assetType, srcAlbumAsset, dstAlbumAsset, albumUri);
823 }
824 EXPECT_NE(errCode, false);
825 }
826
827 /*
828 * Feature: MediaLibrary
829 * Function: ModifyMediaAlbumAsset
830 * SubFunction: NA
831 * FunctionPoints: NA
832 * EnvConditions: NA
833 * CaseDescription: Modify image album asset in requested "non existing" directory.
834 */
835 HWTEST_F(MediaLibraryUnitTest, medialibrary_ModifyMediaAlbumAsset_test_002, TestSize.Level1)
836 {
837 bool errCode = true;
838 AlbumAsset srcAlbumAsset;
839 AlbumAsset dstAlbumAsset;
840 string albumUri;
841 AssetType assetType = ASSET_IMAGEALBUM;
842
843 srcAlbumAsset.SetAlbumName("test/album001");
844 dstAlbumAsset.SetAlbumName("modify_album002");
845 albumUri = "/storage/media/local/files/test2/album001";
846 if (g_mediaLibClientInstance != nullptr) {
847 errCode = g_mediaLibClientInstance->ModifyMediaAlbumAsset(assetType, srcAlbumAsset, dstAlbumAsset, albumUri);
848 }
849 EXPECT_EQ(errCode, false);
850 }
851
852 /*
853 * Feature: MediaLibrary
854 * Function: DeleteMediaAlbumAsset
855 * SubFunction: NA
856 * FunctionPoints: NA
857 * EnvConditions: NA
858 * CaseDescription: Delete media album from requested directory path.
859 */
860 HWTEST_F(MediaLibraryUnitTest, medialibrary_DeleteMediaAlbumAsset_testlevel0_001, TestSize.Level0)
861 {
862 bool errCode = false;
863 AlbumAsset albumAsset;
864 string albumUri;
865 struct stat statInfo {};
866 AssetType assetType = ASSET_IMAGEALBUM;
867
868 albumAsset.SetAlbumName("gtest/copyjpg/001/modify_image001");
869 albumUri = "/storage/media/local/files/gtest/copyjpg/001/modify_image001";
870 if (stat(albumUri.c_str(), &statInfo) == 0) {
871 if (statInfo.st_mode & S_IFDIR) {
872 if (g_mediaLibClientInstance != nullptr) {
873 errCode = g_mediaLibClientInstance->DeleteMediaAlbumAsset(assetType, albumAsset, albumUri);
874 }
875 }
876 }
877 EXPECT_NE(errCode, false);
878 }
879
880 /*
881 * Feature: MediaLibrary
882 * Function: DeleteMediaAlbumAsset
883 * SubFunction: NA
884 * FunctionPoints: NA
885 * EnvConditions: NA
886 * CaseDescription: Delete media album from requested non existing path.
887 */
888 HWTEST_F(MediaLibraryUnitTest, medialibrary_DeleteMediaAlbumAsset_test_002, TestSize.Level1)
889 {
890 bool errCode = true;
891 AlbumAsset albumAsset;
892 string albumUri;
893 AssetType assetType = ASSET_IMAGEALBUM;
894
895 albumAsset.SetAlbumName("gtest/modify_album001");
896 albumUri = "/storage/media/local/files/test/modify_album002";
897 if (g_mediaLibClientInstance != nullptr) {
898 errCode = g_mediaLibClientInstance->DeleteMediaAlbumAsset(assetType, albumAsset, albumUri);
899 }
900 EXPECT_EQ(errCode, false);
901 }
902 } // namespace Media
903 } // namespace OHOS
904
