1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdint>
17 #include <fstream>
18 #include <iostream>
19
20 #include "media_library_manager_test.h"
21 #include "datashare_helper.h"
22 #include "fetch_result.h"
23 #include "file_asset.h"
24 #include "get_self_permissions.h"
25 #include "hilog/log.h"
26 #include "iservice_registry.h"
27 #include "media_app_uri_permission_column.h"
28 #include "medialibrary_db_const.h"
29 #include "medialibrary_errno.h"
30 #include "media_file_utils.h"
31 #include "media_library_manager.h"
32 #include "media_log.h"
33 #include "media_volume.h"
34 #include "photo_proxy_test.h"
35 #include "result_set_utils.h"
36 #include "scanner_utils.h"
37 #include "system_ability_definition.h"
38
39 using namespace std;
40 using namespace OHOS;
41 using namespace testing::ext;
42 using namespace OHOS::NativeRdb;
43 using namespace OHOS::AppExecFwk;
44
45 /**
46 * @FileName MediaLibraryManagerTest
47 * @Desc Media library manager native function test
48 *
49 */
50 namespace OHOS {
51 namespace Media {
52 const string API_VERSION = "api_version";
53 std::shared_ptr<DataShare::DataShareHelper> sDataShareHelper_ = nullptr;
54 std::unique_ptr<FileAsset> GetFile(int mediaTypeId);
55 void ClearFile();
56 void ClearAllFile();
57 void CreateDataHelper(int32_t systemAbilityId);
58
59 constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
60 int g_albumMediaType = MEDIA_TYPE_ALBUM;
61 int64_t g_oneImageSize = 0;
62 const int CLEAN_TIME = 5;
63 const int SCAN_WAIT_TIME = 10;
64 constexpr int32_t OWNER_PRIVIEDGE = 4;
65 constexpr int32_t TYPE_PHOTOS = 1;
66 constexpr int32_t TYPE_AUDIOS = 2;
67 constexpr int32_t MAX_PERMISSION_INDEX = 2;
68 uint64_t tokenId = 0;
69 int32_t txtIndex = 0;
70 int32_t audioIndex = 0;
71 int32_t randomNumber = 0;
72
73 static const unsigned char FILE_CONTENT_TXT[] = {
74 0x49, 0x44, 0x33, 0x03, 0x20, 0x20, 0x20, 0x0c, 0x24
75 };
76
77 static const unsigned char FILE_CONTENT_JPG[] = {
78 0x49, 0x44, 0x33, 0x03, 0x20, 0x20, 0x20, 0x0c, 0x24, 0x5d, 0x54, 0x45, 0x4e, 0x43, 0x20, 0x20, 0x20, 0x0b,
79 0x20, 0x20, 0x20,
80 };
81
82 static const unsigned char FILE_CONTENT_MP4[] = {
83 0x20, 0x20, 0x20, 0x20, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d, 0x20, 0x20, 0x02, 0x20, 0x69, 0x73, 0x6f,
84 0x6d, 0x69, 0x73, 0x6f, 0x32, 0x61, 0x76, 0x63, 0x31, 0x6d, 0x70, 0x34, 0x31, 0x20, 0x20, 0x20, 0x08, 0x66, 0x72,
85 0x65, 0x65, 0x20, 0x49, 0xdd, 0x01, 0x6d, 0x64, 0x61, 0x74, 0x20, 0x20, 0x02, 0xa0, 0x06, 0x05, 0xff, 0xff, 0x9c,
86 };
87
88 static const unsigned char FILE_CONTENT_MP3[] = {
89 0x49, 0x44, 0x33, 0x03, 0x20, 0x20, 0x20, 0x0c, 0x24, 0x5d, 0x54, 0x45, 0x4e, 0x43, 0x20, 0x20, 0x20, 0x0b, 0x20,
90 0x20, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x54, 0x6f, 0x6f, 0x6c, 0x73, 0x20, 0x54, 0x58, 0x58, 0x58, 0x20, 0x20, 0x20,
91 0x27, 0x20, 0x20, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x72, 0x65, 0x66, 0x65,
92 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x21, 0x46, 0x6c, 0x4c, 0x55, 0x6b, 0x6e, 0x45, 0x6d, 0x52, 0x62, 0x61, 0x61,
93 0x61, 0x47, 0x6b, 0x20, 0x54, 0x59, 0x45, 0x52, 0x20, 0x20, 0x20, 0x06, 0x20, 0x20, 0x20, 0x32, 0x30, 0x31, 0x35,
94 0x20, 0x54, 0x44, 0x41, 0x54, 0x20, 0x20, 0x20, 0x06, 0x20, 0x20, 0x20, 0x32, 0x33, 0x31, 0x31, 0x20, 0x54, 0x58,
95 0x58, 0x58, 0x20, 0x20, 0x20, 0x17, 0x20, 0x20, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x65, 0x72,
96 0x65, 0x6e, 0x63, 0x65, 0x20, 0x31, 0x36, 0x36, 0x31, 0x31, 0x39, 0x20, 0x54, 0x43, 0x4f, 0x4d, 0x20, 0x20, 0x20,
97 0x09, 0x20, 0x20, 0x01, 0xff, 0xfe, 0x4b, 0x6d, 0xd5, 0x8b, 0x20, 0x20, 0x54, 0x50, 0x45, 0x31, 0x20, 0x20, 0x20,
98 0x0f, 0x20, 0x20, 0x01, 0xff, 0xfe, 0x43, 0x51, 0x70, 0x65, 0x6e, 0x63, 0x4b, 0x6d, 0xd5, 0x8b, 0x20, 0x20, 0x54,
99 0x41, 0x4c, 0x42, 0x20, 0x20, 0x20, 0x07, 0x20, 0x20, 0x20, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x20, 0x54, 0x49, 0x54,
100 0x32, 0x20, 0x20, 0x20, 0x06, 0x20, 0x20, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x54, 0x50, 0x45, 0x32, 0x20, 0x20,
101 0x20, 0x0c, 0x20, 0x20, 0x20, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x20, 0x54, 0x58, 0x58,
102 0x58, 0x20, 0x20, 0x20, 0x0e, 0x20, 0x20, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x64, 0x69,
103 0x61, 0x20, 0x54, 0x43, 0x4f, 0x4e, 0x20, 0x20, 0x20, 0x09, 0x20, 0x20, 0x20, 0x4c, 0x79, 0x72, 0x69, 0x63, 0x61,
104 0x6c, 0x20, 0x54, 0x53, 0x53, 0x45, 0x20, 0x20, 0x20, 0x0f, 0x20, 0x20, 0x20, 0x4c, 0x61
105 };
106
107 MediaLibraryManager* mediaLibraryManager = MediaLibraryManager::GetMediaLibraryManager();
108
SetUpTestCase(void)109 void MediaLibraryManagerTest::SetUpTestCase(void)
110 {
111 vector<string> perms;
112 perms.push_back("ohos.permission.READ_MEDIA");
113 perms.push_back("ohos.permission.WRITE_MEDIA");
114 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
115 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
116 perms.push_back("ohos.permission.MEDIA_LOCATION");
117 perms.push_back("ohos.permission.GET_BUNDLE_INFO_PRIVILEGED");
118 uint64_t tokenId = 0;
119 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
120 ASSERT_TRUE(tokenId != 0);
121
122 MEDIA_INFO_LOG("MediaLibraryManagerTest::SetUpTestCase:: invoked");
123 CreateDataHelper(STORAGE_MANAGER_MANAGER_ID);
124 if (sDataShareHelper_ == nullptr) {
125 EXPECT_NE(sDataShareHelper_, nullptr);
126 return;
127 }
128
129 // make sure board is empty
130 ClearAllFile();
131
132 Uri scanUri(URI_SCANNER);
133 DataShareValuesBucket valuesBucket;
134 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
135 sDataShareHelper_->Insert(scanUri, valuesBucket);
136 sleep(SCAN_WAIT_TIME);
137
138 MEDIA_INFO_LOG("MediaLibraryManagerTest::SetUpTestCase:: Finish");
139 }
140
TearDownTestCase(void)141 void MediaLibraryManagerTest::TearDownTestCase(void)
142 {
143 MEDIA_ERR_LOG("TearDownTestCase start");
144 if (sDataShareHelper_ != nullptr) {
145 sDataShareHelper_->Release();
146 }
147 sleep(CLEAN_TIME);
148 ClearAllFile();
149 MEDIA_INFO_LOG("TearDownTestCase end.");
150 }
151
152 // SetUp:Execute before each test case
SetUp(void)153 void MediaLibraryManagerTest::SetUp(void)
154 {
155 vector<string> perms;
156 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
157 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
158 perms.push_back("ohos.permission.READ_AUDIO");
159 perms.push_back("ohos.permission.WRITE_AUDIO");
160 perms.push_back("ohos.permission.READ_MEDIA");
161 perms.push_back("ohos.permission.WRITE_MEDIA");
162 perms.push_back("ohos.permission.MEDIA_LOCATION");
163 perms.push_back("ohos.permission.GET_BUNDLE_INFO_PRIVILEGED");
164 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
165 system("rm -rf /storage/cloud/100/files/Photo/*");
166 }
167
TearDown(void)168 void MediaLibraryManagerTest::TearDown(void) {}
169
CreateDataHelper(int32_t systemAbilityId)170 void CreateDataHelper(int32_t systemAbilityId)
171 {
172 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
173 if (saManager == nullptr) {
174 MEDIA_ERR_LOG("Get system ability mgr failed.");
175 return;
176 }
177 auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
178 if (remoteObj == nullptr) {
179 MEDIA_ERR_LOG("GetSystemAbility Service Failed.");
180 return;
181 }
182 mediaLibraryManager->InitMediaLibraryManager(remoteObj);
183 MEDIA_INFO_LOG("InitMediaLibraryManager success!");
184
185 if (sDataShareHelper_ == nullptr) {
186 const sptr<IRemoteObject> &token = remoteObj;
187 sDataShareHelper_ = DataShare::DataShareHelper::Creator(token, MEDIALIBRARY_DATA_URI);
188 }
189 mediaLibraryManager->InitMediaLibraryManager(remoteObj);
190 }
191
ClearAllFile()192 void ClearAllFile()
193 {
194 system("rm -rf /storage/media/100/local/files/.thumbs/*");
195 system("rm -rf /storage/cloud/100/files/Audio/*");
196 system("rm -rf /storage/cloud/100/files/Audios/*");
197 system("rm -rf /storage/cloud/100/files/Camera/*");
198 system("rm -rf /storage/cloud/100/files/Documents/*");
199 system("rm -rf /storage/cloud/100/files/Photo/*");
200 system("rm -rf /storage/cloud/100/files/Pictures/*");
201 system("rm -rf /storage/cloud/100/files/Download/*");
202 system("rm -rf /storage/cloud/100/files/Videos/*");
203 system("rm -rf /storage/cloud/100/files/.*");
204 system("rm -rf /data/app/el2/100/database/com.ohos.medialibrary.medialibrarydata/*");
205 system("kill -9 `pidof com.ohos.medialibrary.medialibrarydata`");
206 system("scanner");
207 }
208
DeleteFile(std::string fileUri)209 void DeleteFile(std::string fileUri)
210 {
211 if (sDataShareHelper_ == nullptr) {
212 return;
213 }
214 Uri deleteAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN);
215 DataShare::DataSharePredicates predicates;
216 predicates.EqualTo(MEDIA_DATA_DB_ID, MediaFileUtils::GetIdFromUri(fileUri));
217 int retVal = sDataShareHelper_->Delete(deleteAssetUri, predicates);
218 MEDIA_INFO_LOG("MediaSpaceStatistics_test DeleteFile::uri :%{private}s", deleteAssetUri.ToString().c_str());
219 EXPECT_NE(retVal, E_ERR);
220 }
221
ClearFile()222 void ClearFile()
223 {
224 if (sDataShareHelper_ == nullptr) {
225 return;
226 }
227 vector<string> columns;
228 DataSharePredicates predicates;
229 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> " + to_string(g_albumMediaType);
230 predicates.SetWhereClause(prefix);
231 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
232 shared_ptr<DataShareResultSet> resultSet = nullptr;
233 resultSet = sDataShareHelper_->Query(queryFileUri, predicates, columns);
234 EXPECT_NE((resultSet == nullptr), true);
235
236 unique_ptr<FetchResult<FileAsset>> fetchFileResult = make_unique<FetchResult<FileAsset>>(move(resultSet));
237 EXPECT_NE((fetchFileResult->GetCount() < 0), true);
238 unique_ptr<FileAsset> fileAsset = fetchFileResult->GetFirstObject();
239 while (fileAsset != nullptr) {
240 DeleteFile(fileAsset->GetUri());
241 fileAsset = fetchFileResult->GetNextObject();
242 }
243 }
244
CreateFile(std::string baseURI,std::string targetPath,std::string newName,MediaType mediaType,const unsigned char fileContent[])245 static string CreateFile(std::string baseURI, std::string targetPath, std::string newName, MediaType mediaType,
246 const unsigned char fileContent[])
247 {
248 bool audioFlag = false;
249 MEDIA_INFO_LOG("CreateFile:: start Create file: %s", newName.c_str());
250 if (sDataShareHelper_ == nullptr) {
251 return "";
252 }
253 string abilityUri = Media::MEDIALIBRARY_DATA_URI;
254 if (MediaFileUtils::StartsWith(targetPath, "Audios/")) {
255 audioFlag = true;
256 abilityUri += Media::MEDIA_AUDIOOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET;
257 } else {
258 abilityUri += Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET;
259 }
260 Uri createAssetUri(abilityUri);
261 DataShareValuesBucket valuesBucket;
262 valuesBucket.Put(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
263 valuesBucket.Put(MEDIA_DATA_DB_NAME, newName);
264 valuesBucket.Put(MEDIA_DATA_DB_RELATIVE_PATH, targetPath);
265 int32_t index = sDataShareHelper_->Insert(createAssetUri, valuesBucket);
266
267 int64_t virtualIndex = MediaFileUtils::GetVirtualIdByType(index, mediaType);
268 string destUri = baseURI + "/" + std::to_string(virtualIndex);
269 string getUri = baseURI + "/" + std::to_string(index);
270
271 Uri openFileUriDest(destUri);
272 int32_t destFd = sDataShareHelper_->OpenFile(openFileUriDest, MEDIA_FILEMODE_READWRITE);
273 EXPECT_NE(destFd <= 0, true);
274 int len;
275 if (audioFlag == true) {
276 len = sizeof(FILE_CONTENT_MP3);
277 } else {
278 len = sizeof(FILE_CONTENT_TXT);
279 }
280 int32_t resWrite = write(destFd, fileContent, len);
281 if (resWrite == -1) {
282 EXPECT_EQ(false, true);
283 }
284 mediaLibraryManager->CloseAsset(destUri, destFd);
285 MEDIA_INFO_LOG("CreateFile:: end Create file: %s", newName.c_str());
286 return getUri;
287 }
288
CreatePhotoAsset(string displayName)289 static string CreatePhotoAsset(string displayName)
290 {
291 int32_t resWrite = -1;
292 auto uri = mediaLibraryManager->CreateAsset(displayName);
293 int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
294 EXPECT_NE(destFd <= 0, true);
295 if (displayName.find(".jpg") != std::string::npos) {
296 resWrite = write(destFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
297 } else if (displayName.find(".mp4") != std::string::npos) {
298 resWrite = write(destFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
299 }
300 if (resWrite == -1) {
301 EXPECT_EQ(false, true);
302 }
303 return uri;
304 }
305
DeletAssetInDb(const string uri,int32_t uriType)306 static void DeletAssetInDb(const string uri, int32_t uriType)
307 {
308 string deleteUri;
309 if (sDataShareHelper_ == nullptr) {
310 return;
311 }
312 if (uriType == TYPE_PHOTOS) {
313 deleteUri = MEDIALIBRARY_DATA_URI + "/" + MEDIA_PHOTOOPRN + "/" + MEDIA_FILEOPRN_DELETEASSET;
314 } else if (uriType == TYPE_AUDIOS) {
315 deleteUri = MEDIALIBRARY_DATA_URI + "/" + MEDIA_AUDIOOPRN + "/" + MEDIA_FILEOPRN_DELETEASSET;
316 }
317 Uri deleteAssetUri(deleteUri);
318 DataSharePredicates predicates;
319 predicates.EqualTo(MEDIA_DATA_DB_ID, MediaFileUtils::GetIdFromUri(uri));
320 int retVal = sDataShareHelper_->Delete(deleteAssetUri, predicates);
321 EXPECT_NE(retVal, E_ERR);
322 MEDIA_INFO_LOG("DeleteAsset succeed!");
323 }
324
QueryUriPermissionResult(string appid,vector<string> inColumn,int32_t mediaType,std::shared_ptr<DataShareResultSet> & queryResult)325 static void QueryUriPermissionResult(string appid, vector<string> inColumn, int32_t mediaType,
326 std::shared_ptr<DataShareResultSet> &queryResult)
327 {
328 DataSharePredicates predicates;
329 vector<string> columns;
330 DatashareBusinessError error;
331 predicates.In(AppUriPermissionColumn::FILE_ID, inColumn);
332 predicates.And()->EqualTo(AppUriPermissionColumn::APP_ID, appid);
333 predicates.And()->EqualTo(AppUriPermissionColumn::URI_TYPE, to_string(mediaType));
334 predicates.OrderByAsc(AppUriPermissionColumn::FILE_ID);
335 Uri queryUri(MEDIALIBRARY_GRANT_URIPERM_URI);
336 ASSERT_NE(sDataShareHelper_, nullptr);
337 queryResult = sDataShareHelper_->Query(queryUri, predicates, columns, &error);
338 ASSERT_NE(queryResult, nullptr);
339 }
340
CreateOwnerPrivliegeAssets(string appid)341 static string CreateOwnerPrivliegeAssets(string appid)
342 {
343 string photoUri = CreatePhotoAsset("test.jpg");
344 Uri insertUri(MEDIALIBRARY_GRANT_URIPERM_URI);
345 string fileId = MediaFileUtils::GetIdFromUri(photoUri);
346 DataShareValuesBucket ValuesBucket;
347
348 ValuesBucket.Put(AppUriPermissionColumn::FILE_ID, static_cast<int32_t>(std::stoi(fileId)));
349 ValuesBucket.Put(AppUriPermissionColumn::APP_ID, appid);
350 ValuesBucket.Put(AppUriPermissionColumn::PERMISSION_TYPE, OWNER_PRIVIEDGE);
351 ValuesBucket.Put(AppUriPermissionColumn::URI_TYPE, TYPE_PHOTOS);
352 ValuesBucket.Put(AppUriPermissionColumn::DATE_MODIFIED, MediaFileUtils::UTCTimeMilliSeconds());
353 sDataShareHelper_->Insert(insertUri, ValuesBucket);
354 return photoUri;
355 }
356
GetRandomTemporaryPermission()357 static PhotoPermissionType GetRandomTemporaryPermission()
358 {
359 randomNumber++;
360 if (randomNumber > MAX_PERMISSION_INDEX) {
361 randomNumber = 0;
362 }
363 if (randomNumber == 0) {
364 return PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
365 } else if (randomNumber == 1) {
366 return PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
367 } else {
368 return PhotoPermissionType::TEMPORARY_READWRITE_IMAGEVIDEO;
369 }
370 }
371
CompareIfArraysEquals(const unsigned char originArray[],const unsigned char targetArray[],int32_t size)372 static bool CompareIfArraysEquals(const unsigned char originArray[],
373 const unsigned char targetArray[], int32_t size)
374 {
375 for (int i = 0; i < size - 1; i++) {
376 if (originArray[i] != targetArray[i]) {
377 return false;
378 }
379 }
380 return true;
381 }
382
383 /**
384 * @tc.number : MediaLibraryManager_test_001
385 * @tc.name : create a test.jpg
386 * @tc.desc : create a image asset to see if error occurs
387 */
388 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_001, TestSize.Level0)
389 {
390 MEDIA_INFO_LOG("MediaLibraryManager_test_001::Start");
391 string displayName = "test.jpg";
392 string uri = mediaLibraryManager->CreateAsset(displayName);
393 EXPECT_NE(uri, "");
394 int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
395 EXPECT_NE(destFd <= 0, true);
396 int32_t resWrite = write(destFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
397 if (resWrite == -1) {
398 EXPECT_EQ(false, true);
399 }
400 auto ret = mediaLibraryManager->CloseAsset(uri, destFd);
401 EXPECT_EQ(ret, E_SUCCESS);
402 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str());
403 }
404
405 /**
406 * @tc.number : MediaLibraryManager_test_002
407 * @tc.name : create image again to see if error occurs
408 * @tc.desc : create same name file to see if error occur and
409 * : read image msg to see if equals
410 */
411 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_002, TestSize.Level0)
412 {
413 MEDIA_INFO_LOG("MediaLibraryManager_test_002::Start");
414 string displayName = "test2.jpg";
415 string uri = mediaLibraryManager->CreateAsset(displayName);
416 MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str());
417 EXPECT_NE(uri, "");
418 int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
419 EXPECT_NE(destFd <= 0, true);
420 int32_t resWrite = write(destFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
421 if (resWrite == -1) {
422 EXPECT_EQ(false, true);
423 }
424 mediaLibraryManager->CloseAsset(uri, destFd);
425
426 int32_t srcFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
427 int64_t srcLen = lseek(srcFd, 0, SEEK_END);
428 lseek(srcFd, 0, SEEK_SET);
429 unsigned char *buf = static_cast<unsigned char*>(malloc(srcLen));
430 EXPECT_NE((buf == nullptr), true);
431 read(srcFd, buf, srcLen);
432 free(buf);
433 EXPECT_EQ(CompareIfArraysEquals(buf, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG)), true);
434 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str());
435 }
436
437 /**
438 * @tc.number : MediaLibraryManager_test_003
439 * @tc.name : create video to see if error occurs
440 * @tc.desc : create video file to see if error occur and
441 * : read video msg to see if equals
442 */
443 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_003, TestSize.Level0)
444 {
445 MEDIA_INFO_LOG("MediaLibraryManager_test_003::Start");
446 string displayName = "testVideo.mp4";
447 string uri = mediaLibraryManager->CreateAsset(displayName);
448 MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str());
449 EXPECT_NE(uri, "");
450 int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
451 EXPECT_NE(destFd <= 0, true);
452 int32_t resWrite = write(destFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
453 if (resWrite == -1) {
454 EXPECT_EQ(false, true);
455 }
456 mediaLibraryManager->CloseAsset(uri, destFd);
457 int32_t srcFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
458 int64_t srcLen = lseek(srcFd, 0, SEEK_END);
459 lseek(srcFd, 0, SEEK_SET);
460 unsigned char *buf = static_cast<unsigned char*>(malloc(srcLen));
461 EXPECT_NE((buf == nullptr), true);
462 read(srcFd, buf, srcLen);
463 free(buf);
464 EXPECT_EQ(CompareIfArraysEquals(buf, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4)), true);
465 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str());
466 }
467
468 /**
469 * @tc.number : MediaLibraryManager_test_004
470 * @tc.name : create error type asset testVideo.xxx to see if error occurs
471 * @tc.desc : create error type asset to see if error occurs
472 */
473 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_004, TestSize.Level0)
474 {
475 MEDIA_INFO_LOG("MediaLibraryManager_test_004::Start");
476 string displayName = "testVideo.xxx";
477 string uri = mediaLibraryManager->CreateAsset(displayName);
478 MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str());
479 EXPECT_EQ(uri, "");
480 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str());
481 }
482
483 /**
484 * @tc.number : MediaLibraryManager_test_005
485 * @tc.name : create png image again to see if error occurs
486 * @tc.desc : create png image to see if error occur and
487 * : read image msg to see if equals
488 */
489 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_005, TestSize.Level0)
490 {
491 MEDIA_INFO_LOG("MediaLibraryManager_test_005::Start");
492 string displayName = "testPNG.png";
493 string uri = mediaLibraryManager->CreateAsset(displayName);
494 MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str());
495 EXPECT_NE(uri, "");
496 int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
497 EXPECT_NE(destFd <= 0, true);
498 int32_t resWrite = write(destFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
499 if (resWrite == -1) {
500 EXPECT_EQ(false, true);
501 }
502 mediaLibraryManager->CloseAsset(uri, destFd);
503
504 int32_t srcFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
505 int64_t srcLen = lseek(srcFd, 0, SEEK_END);
506 lseek(srcFd, 0, SEEK_SET);
507 unsigned char *buf = static_cast<unsigned char*>(malloc(srcLen));
508 EXPECT_NE((buf == nullptr), true);
509 read(srcFd, buf, srcLen);
510 free(buf);
511 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str());
512 }
513
514 /**
515 * @tc.number : MediaLibraryManager_GetBatchAstcs_test_006
516 * @tc.name : Query astc batch to see if error occurs
517 * @tc.desc : Input uri list to obtain astc bacth
518 */
519 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GetBatchAstcs_test_006, TestSize.Level0)
520 {
521 vector<string> uriBatch;
522 vector<vector<uint8_t>> astcBatch;
523 int ret = mediaLibraryManager->GetBatchAstcs(uriBatch, astcBatch);
524 EXPECT_EQ(ret, E_INVALID_URI);
525
526 string beginUri = "file://media/Photo/64/IMG_063/IMG_11311.jpg?oper=astc&width=256&height=256&time_id=00000001";
527 uriBatch.push_back("0000000001");
528 ret = mediaLibraryManager->GetBatchAstcs(uriBatch, astcBatch);
529 EXPECT_EQ(ret, E_INVALID_URI);
530
531 uriBatch.clear();
532 uriBatch.push_back(beginUri);
533 ret = mediaLibraryManager->GetBatchAstcs(uriBatch, astcBatch);
534 EXPECT_EQ(ret, E_INVALID_URI);
535
536 uriBatch.clear();
537 beginUri = "file://media/Photo/64/IMG_063/IMG_11311.jpg?oper=astc&width=128&height=128&time_id=00000001";
538 uriBatch.push_back(beginUri);
539 ret = mediaLibraryManager->GetBatchAstcs(uriBatch, astcBatch);
540
541 uriBatch.clear();
542 beginUri = "file://media/Photo/64/IMG_063/IMG_11311.jpg?oper=astc&width=64&height=64&time_id=00000001";
543 uriBatch.push_back(beginUri);
544 ret = mediaLibraryManager->GetBatchAstcs(uriBatch, astcBatch);
545 }
546
547 /**
548 * @tc.number : MediaLibraryManager_GetAstc_test_007
549 * @tc.name : Get astc image to see if error occurs
550 * @tc.desc : Input uri to obtain astc
551 */
552 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GetAstc_test_007, TestSize.Level0)
553 {
554 string uriStr1 = "file://media/Photo/64/test?oper=thumbnail&width=256&height=256&path=test";
555 auto pixelmap1 = mediaLibraryManager->GetAstc(Uri(uriStr1));
556 EXPECT_EQ(pixelmap1, nullptr);
557
558 string uriStr2 = "file://media/Photo/64/testoper=astc&width=256&height=256&path=test";
559 auto pixelmap2 = mediaLibraryManager->GetAstc(Uri(uriStr2));
560 EXPECT_EQ(pixelmap2, nullptr);
561
562 string uriStr3 = "file://media/Photo/64/test?oper=astc&width=256&height=256&path=test";
563 auto pixelmap3 = mediaLibraryManager->GetAstc(Uri(uriStr3));
564 EXPECT_EQ(pixelmap3, nullptr);
565 }
566
567 /**
568 * @tc.number : MediaLibraryManager_test_008
569 * @tc.name : Read video of moving photo to see if error occurs
570 * @tc.desc : Input uri to read video of moving photo
571 */
572 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_008, TestSize.Level0)
573 {
574 // read invalid uri
575 EXPECT_EQ(mediaLibraryManager->ReadMovingPhotoVideo(""), -1);
576 EXPECT_EQ(mediaLibraryManager->ReadMovingPhotoVideo("file://media/Photo"), -1);
577 EXPECT_EQ(mediaLibraryManager->ReadMovingPhotoVideo("file://media/Photo/1"), -1);
578 EXPECT_EQ(mediaLibraryManager->ReadMovingPhotoVideo("file://media/Photo/1/IMG_008/IMG_008.jpg"), -1);
579
580 string displayName = "movingPhoto.jpg";
581 string uri = mediaLibraryManager->CreateAsset(displayName);
582 MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str());
583 EXPECT_NE(uri, "");
584
585 int32_t fd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
586 EXPECT_GE(fd, 0);
587 mediaLibraryManager->CloseAsset(uri, fd);
588
589 int32_t rfd = mediaLibraryManager->ReadMovingPhotoVideo(uri);
590 EXPECT_LE(rfd, 0);
591 }
592
593 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_009, TestSize.Level0)
594 {
595 // read invalid uri
596 EXPECT_EQ(mediaLibraryManager->ReadPrivateMovingPhoto(""), -1);
597 EXPECT_EQ(mediaLibraryManager->ReadPrivateMovingPhoto("file://media/Photo"), -1);
598 EXPECT_EQ(mediaLibraryManager->ReadPrivateMovingPhoto("file://media/Photo/1"), -1);
599 EXPECT_EQ(mediaLibraryManager->ReadPrivateMovingPhoto("file://media/Photo/1/IMG_009/IMG_009.jpg"), -1);
600
601 string displayName = "movingPhoto.jpg";
602 string uri = mediaLibraryManager->CreateAsset(displayName);
603 MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str());
604 EXPECT_NE(uri, "");
605
606 int32_t fd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE);
607 EXPECT_GE(fd, 0);
608 mediaLibraryManager->CloseAsset(uri, fd);
609 }
610
611 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CreatePhotoAssetProxy_test_001, TestSize.Level0)
612 {
613 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_001 enter");
614 auto photoAssetProxy = mediaLibraryManager->CreatePhotoAssetProxy(CameraShotType::MOVING_PHOTO, 0, 0);
615 ASSERT_NE(photoAssetProxy, nullptr);
616 sptr<PhotoProxyTest> photoProxyTest = new(std::nothrow) PhotoProxyTest();
617 ASSERT_NE(photoProxyTest, nullptr);
618 string titleExpect = photoProxyTest->GetTitle();
619 photoProxyTest->SetFormat(PhotoFormat::JPG);
620 photoProxyTest->SetPhotoQuality(PhotoQuality::LOW);
621
622 photoAssetProxy->AddPhotoProxy((sptr<PhotoProxy>&)photoProxyTest);
623
624 auto fileAsset = photoAssetProxy->GetFileAsset();
625 ASSERT_NE(fileAsset, nullptr);
626 EXPECT_EQ(fileAsset->GetTitle(), titleExpect);
627 EXPECT_EQ(fileAsset->GetResultNapiType(), ResultNapiType::TYPE_PHOTOACCESS_HELPER);
628
629 vector<string> columns { PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_QUALITY, PhotoColumn::PHOTO_DIRTY,
630 PhotoColumn::PHOTO_IS_TEMP };
631 DataSharePredicates predicates;
632 predicates.EqualTo(MediaColumn::MEDIA_ID, fileAsset->GetId());
633
634 string uriStr = URI_QUERY_PHOTO;
635 MediaFileUtils::UriAppendKeyValue(uriStr, API_VERSION, to_string(MEDIA_API_VERSION_V10));
636 Uri queryFileUri(uriStr);
637 shared_ptr<DataShareResultSet> resultSet = nullptr;
638 resultSet = sDataShareHelper_->Query(queryFileUri, predicates, columns);
639 ASSERT_NE(resultSet, nullptr);
640 ASSERT_EQ(resultSet->GoToFirstRow(), E_OK);
641
642 EXPECT_EQ(photoProxyTest->GetPhotoId(), GetStringVal(PhotoColumn::PHOTO_ID, resultSet));
643 EXPECT_EQ(-1, GetInt32Val(PhotoColumn::PHOTO_DIRTY, resultSet));
644 EXPECT_EQ(1, GetInt32Val(PhotoColumn::PHOTO_IS_TEMP, resultSet));
645
646 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_001 exit");
647 }
648
649 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CreatePhotoAssetProxy_test_002, TestSize.Level0)
650 {
651 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_002 enter");
652 auto photoAssetProxy = mediaLibraryManager->CreatePhotoAssetProxy(CameraShotType::MOVING_PHOTO, 0, 0);
653 sptr<PhotoProxyTest> photoProxyTest = new(std::nothrow) PhotoProxyTest();
654 ASSERT_NE(photoProxyTest, nullptr);
655
656 photoAssetProxy->AddPhotoProxy((sptr<PhotoProxy>&)photoProxyTest);
657 int32_t fd = photoAssetProxy->GetVideoFd();
658 EXPECT_GE(fd, 0);
659 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_002 exit");
660 }
661
662 /**
663 * @brief verify PhotoAssetProxy::UpdatePhotoBurst
664 *
665 * GIVEN ProtoProxy::GetBurstKey()
666 * WHEN ProtoProxy::GetBurstKey() is xxxxxxxx-xxxx-xxxx-xxxxxxxx-xxxx
667 * THEN media_library.db#Photos#burstKey is xxxxxxxx-xxxx-xxxx-xxxxxxxx-xxxx
668 */
669 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CreatePhotoAssetProxy_test_003, TestSize.Level0)
670 {
671 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_003 enter");
672 auto photoAssetProxy = mediaLibraryManager->CreatePhotoAssetProxy(CameraShotType::BURST, 0, 0);
673 ASSERT_NE(photoAssetProxy, nullptr);
674 // mock data for PhotoProxy
675 sptr<PhotoProxyTest> photoProxyTest = new(std::nothrow) PhotoProxyTest();
676 photoProxyTest->SetIsCoverPhoto(false);
677 std::string burstKey = "xxxxxxxx-xxxx-xxxx-xxxxxxxx-xxxx";
678 photoProxyTest->SetBurstKey(burstKey);
679 ASSERT_NE(photoProxyTest, nullptr);
680 string titleExpect = photoProxyTest->GetTitle();
681 photoProxyTest->SetFormat(PhotoFormat::JPG);
682 photoProxyTest->SetPhotoQuality(PhotoQuality::HIGH);
683 // call PhotoAssetProxy::AddPhotoProxy to access PhotoAssetProxy::UpdatePhotoBurst
684 photoAssetProxy->AddPhotoProxy((sptr<PhotoProxy>&)photoProxyTest);
685 auto fileAsset = photoAssetProxy->GetFileAsset();
686 ASSERT_NE(fileAsset, nullptr);
687 // query from db
688 vector<string> columns{ PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_QUALITY, PhotoColumn::PHOTO_DIRTY,
689 PhotoColumn::PHOTO_BURST_COVER_LEVEL, PhotoColumn::PHOTO_BURST_KEY };
690 DataSharePredicates predicates;
691 predicates.EqualTo(MediaColumn::MEDIA_ID, fileAsset->GetId());
692
693 string uriStr = URI_QUERY_PHOTO;
694 MediaFileUtils::UriAppendKeyValue(uriStr, API_VERSION, to_string(MEDIA_API_VERSION_V10));
695 Uri queryFileUri(uriStr);
696 shared_ptr<DataShareResultSet> resultSet = nullptr;
697 resultSet = sDataShareHelper_->Query(queryFileUri, predicates, columns);
698 ASSERT_NE(resultSet, nullptr);
699 ASSERT_EQ(resultSet->GoToFirstRow(), E_OK);
700
701 // assert
702 EXPECT_EQ(2, GetInt32Val(PhotoColumn::PHOTO_BURST_COVER_LEVEL, resultSet));
703 EXPECT_EQ(burstKey, GetStringVal(PhotoColumn::PHOTO_BURST_KEY, resultSet));
704
705 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_003 exit");
706 }
707
708 /**
709 * @brief verify PhotoAssetProxy::UpdatePhotoBurst
710 *
711 * GIVEN ProtoProxy::IsCoverPhoto()
712 * WHEN ProtoProxy::IsCoverPhoto() is true
713 * THEN media_library.db#Photos#burst_cover_level is 1
714 */
715 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CreatePhotoAssetProxy_test_004, TestSize.Level0)
716 {
717 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_004 enter");
718 auto photoAssetProxy = mediaLibraryManager->CreatePhotoAssetProxy(CameraShotType::BURST, 0, 0);
719 ASSERT_NE(photoAssetProxy, nullptr);
720 // mock data for PhotoProxy
721 sptr<PhotoProxyTest> photoProxyTest = new(std::nothrow) PhotoProxyTest();
722 photoProxyTest->SetIsCoverPhoto(true);
723 std::string burstKey = "xxxxxxxx-xxxx-xxxx-xxxxxxxx-xxxx";
724 photoProxyTest->SetBurstKey(burstKey);
725 ASSERT_NE(photoProxyTest, nullptr);
726 string titleExpect = photoProxyTest->GetTitle();
727 photoProxyTest->SetFormat(PhotoFormat::JPG);
728 photoProxyTest->SetPhotoQuality(PhotoQuality::HIGH);
729 // call PhotoAssetProxy::AddPhotoProxy to access PhotoAssetProxy::UpdatePhotoBurst
730 photoAssetProxy->AddPhotoProxy((sptr<PhotoProxy>&)photoProxyTest);
731 auto fileAsset = photoAssetProxy->GetFileAsset();
732 ASSERT_NE(fileAsset, nullptr);
733 // query from db
734 vector<string> columns{ PhotoColumn::PHOTO_ID, PhotoColumn::PHOTO_QUALITY, PhotoColumn::PHOTO_DIRTY,
735 PhotoColumn::PHOTO_BURST_COVER_LEVEL, PhotoColumn::PHOTO_BURST_KEY };
736 DataSharePredicates predicates;
737 predicates.EqualTo(MediaColumn::MEDIA_ID, fileAsset->GetId());
738
739 string uriStr = URI_QUERY_PHOTO;
740 MediaFileUtils::UriAppendKeyValue(uriStr, API_VERSION, to_string(MEDIA_API_VERSION_V10));
741 Uri queryFileUri(uriStr);
742 shared_ptr<DataShareResultSet> resultSet = nullptr;
743 resultSet = sDataShareHelper_->Query(queryFileUri, predicates, columns);
744 ASSERT_NE(resultSet, nullptr);
745 ASSERT_EQ(resultSet->GoToFirstRow(), E_OK);
746
747 // assert
748 EXPECT_EQ(1, GetInt32Val(PhotoColumn::PHOTO_BURST_COVER_LEVEL, resultSet));
749 EXPECT_EQ(burstKey, GetStringVal(PhotoColumn::PHOTO_BURST_KEY, resultSet));
750
751 MEDIA_INFO_LOG("MediaLibraryManager_CreatePhotoAssetProxy_test_004 exit");
752 }
753
754 // Scenario1: Test when uriBatch is empty then GetBatchAstcs returns E_INVALID_URI.
755 HWTEST_F(MediaLibraryManagerTest, GetBatchAstcs_ShouldReturnE, TestSize.Level0)
756 {
757 std::vector<std::string> uriBatch;
758 std::vector<std::vector<uint8_t>> astcBatch;
759 EXPECT_EQ(manager.GetBatchAstcs(uriBatch, astcBatch), E_INVALID_URI);
760 }
761
762 // Scenario2: Test when uriBatch contains ML_URI_OFFSET then GetBatchAstcs calls GetAstcsByOffset.
763 HWTEST_F(MediaLibraryManagerTest, GetBatchAstcs_ShouldCallGetAstcsByOffset_001, TestSize.Level0)
764 {
765 std::vector<std::string> uriBatch = {"/media/ml/uri/offset/1"};
766 std::vector<std::vector<uint8_t>> astcBatch;
767 EXPECT_EQ(manager.GetBatchAstcs(uriBatch, astcBatch), E_INVALID_URI);
768 }
769
770 HWTEST_F(MediaLibraryManagerTest, GetBatchAstcs_ShouldCallGetAstcsByOffset_002, TestSize.Level0)
771 {
772 std::vector<std::string> uriBatch = {"/media/ml/uri/offset/1/image?size=100x200"};
773 std::vector<std::vector<uint8_t>> astcBatch;
774 EXPECT_EQ(manager.GetBatchAstcs(uriBatch, astcBatch), E_INVALID_URI);
775 }
776
777 HWTEST_F(MediaLibraryManagerTest, GetBatchAstcs_ShouldCallGetAstcsByOffset_003, TestSize.Level0)
778 {
779 std::vector<std::string> uriBatch = {"/media/ml/uri/offset/1/image?size=32x32"};
780 std::vector<std::vector<uint8_t>> astcBatch;
781 EXPECT_EQ(manager.GetBatchAstcs(uriBatch, astcBatch), E_INVALID_URI);
782 }
783
784 // Scenario3: Test when uriBatch does not contain ML_URI_OFFSET then GetBatchAstcs calls GetAstcsBatch.
785 HWTEST_F(MediaLibraryManagerTest, GetBatchAstcs_ShouldCallGetAstcsBatch_004, TestSize.Level0)
786 {
787 std::vector<std::string> uriBatch = {"/media/ml/uri/1"};
788 std::vector<std::vector<uint8_t>> astcBatch;
789 EXPECT_EQ(manager.GetBatchAstcs(uriBatch, astcBatch), E_INVALID_URI);
790 }
791
792 HWTEST_F(MediaLibraryManagerTest, ReadMovingPhotoVideo_001, TestSize.Level0)
793 {
794 string uri = "";
795 EXPECT_EQ(manager.ReadMovingPhotoVideo(uri), -1);
796 }
797
798 HWTEST_F(MediaLibraryManagerTest, ReadMovingPhotoVideo_002, TestSize.Level0)
799 {
800 string uri = "..;";
801 EXPECT_EQ(manager.ReadMovingPhotoVideo(uri), -1);
802 }
803
804 HWTEST_F(MediaLibraryManagerTest, ReadMovingPhoto_001, TestSize.Level0)
805 {
806 string uri = "";
807 EXPECT_EQ(manager.ReadPrivateMovingPhoto(uri), -1);
808 }
809
810 HWTEST_F(MediaLibraryManagerTest, ReadMovingPhoto_002, TestSize.Level0)
811 {
812 string uri = "..;";
813 EXPECT_EQ(manager.ReadPrivateMovingPhoto(uri), -1);
814 }
815
816 HWTEST_F(MediaLibraryManagerTest, GetMovingPhotoImageUri_001, TestSize.Level0)
817 {
818 std::string uri = "";
819 std::string result = manager.GetMovingPhotoImageUri(uri);
820 EXPECT_EQ(result, "");
821 }
822
823 HWTEST_F(MediaLibraryManagerTest, GetMovingPhotoImageUri_002, TestSize.Level0)
824 {
825 std::string uri = "mediaLibraryUri";
826 std::string result = manager.GetMovingPhotoImageUri(uri);
827 EXPECT_EQ(result, uri);
828 }
829
830 HWTEST_F(MediaLibraryManagerTest, GetMovingPhotoDateModified_001, TestSize.Level0)
831 {
832 MEDIA_INFO_LOG("GetMovingPhotoDateModified_001 enter");
833 int64_t startTime = MediaFileUtils::UTCTimeMilliSeconds();
834 auto photoAssetProxy = mediaLibraryManager->CreatePhotoAssetProxy(CameraShotType::MOVING_PHOTO, 0, 0);
835 ASSERT_NE(photoAssetProxy, nullptr);
836 sptr<PhotoProxyTest> photoProxyTest = new (std::nothrow) PhotoProxyTest();
837 ASSERT_NE(photoProxyTest, nullptr);
838 photoProxyTest->SetFormat(PhotoFormat::JPG);
839 photoProxyTest->SetPhotoQuality(PhotoQuality::LOW);
840 photoAssetProxy->AddPhotoProxy((sptr<PhotoProxy>&)photoProxyTest);
841 auto fileAsset = photoAssetProxy->GetFileAsset();
842 ASSERT_NE(fileAsset, nullptr);
843
844 string filePath = fileAsset->GetPath();
845 string displayName = fileAsset->GetDisplayName();
846 string extrUri = MediaFileUtils::GetExtraUri(displayName, filePath);
847 string assetUri = MediaFileUtils::GetUriByExtrConditions("file://media/Photo/",
848 to_string(fileAsset->GetId()), extrUri);
849 int32_t fd = mediaLibraryManager->OpenAsset(assetUri, MEDIA_FILEMODE_READWRITE);
850 EXPECT_NE(fd <= 0, true);
851 write(fd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
852 mediaLibraryManager->CloseAsset(assetUri, fd);
853
854 int64_t movingPhotoDateModified = mediaLibraryManager->GetMovingPhotoDateModified(assetUri);
855 EXPECT_EQ(movingPhotoDateModified > startTime, false);
856 EXPECT_EQ(movingPhotoDateModified <= MediaFileUtils::UTCTimeMilliSeconds(), true);
857 MEDIA_INFO_LOG("GetMovingPhotoDateModified_001 exit");
858 }
859
860 HWTEST_F(MediaLibraryManagerTest, GetMovingPhotoDateModified_002, TestSize.Level0)
861 {
862 MEDIA_INFO_LOG("GetMovingPhotoDateModified_002 enter");
863 int64_t dateModified = mediaLibraryManager->GetMovingPhotoDateModified("");
864 EXPECT_EQ(dateModified, E_ERR);
865
866 dateModified = mediaLibraryManager->GetMovingPhotoDateModified("file://media/image/1/test/test.jpg");
867 EXPECT_EQ(dateModified, E_ERR);
868
869 dateModified = mediaLibraryManager->GetMovingPhotoDateModified("file://media/Photo/4096/IMG_2024_001/test.jpg");
870 EXPECT_EQ(dateModified, E_ERR);
871 MEDIA_INFO_LOG("GetMovingPhotoDateModified_002 exit");
872 }
873
874 /**
875 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_001
876 * @tc.name : grant photo type uri permissions
877 * @tc.desc : check database grant results whether match
878 */
879 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_001, TestSize.Level0)
880 {
881 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_001 enter");
882 string appid = "granttest1";
883 vector<string> uris;
884 vector<string> inColumn;
885 for (int i = 0; i < 5; i++) {
886 auto uri = CreatePhotoAsset("test.jpg");
887 uris.push_back(uri);
888 inColumn.push_back(MediaFileUtils::GetIdFromUri(uri));
889 }
890 auto permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
891 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
892 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
893 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
894 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryPhotoResult);
895 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
896 do {
897 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryPhotoResult);
898 EXPECT_NE(permissionType, static_cast<int32_t>(PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO));
899 } while (!queryPhotoResult->GoToNextRow());
900 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_001 exit");
901 }
902
903 /**
904 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_002
905 * @tc.name : grant vidio type uri permissions
906 * @tc.desc : check database grant results whether match
907 */
908 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_002, TestSize.Level0)
909 {
910 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_002 enter");
911 string appid = "granttest2";
912 vector<string> uris;
913 vector<string> inColumn;
914 for (int i = 0; i < 5; i++) {
915 auto uri = CreatePhotoAsset("test.mp4");
916 uris.push_back(uri);
917 inColumn.push_back(MediaFileUtils::GetIdFromUri(uri));
918 }
919 auto permissionType = PhotoPermissionType::TEMPORARY_READWRITE_IMAGEVIDEO;
920 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
921 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
922 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
923 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryPhotoResult);
924 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
925 do {
926 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryPhotoResult);
927 EXPECT_NE(permissionType, static_cast<int32_t>(PhotoPermissionType::TEMPORARY_READWRITE_IMAGEVIDEO));
928 } while (!queryPhotoResult->GoToNextRow());
929 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_002 exit");
930 }
931
932 /**
933 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_003
934 * @tc.name : grant audio type for uri permissions
935 * @tc.desc : check database grant results whether match
936 */
937 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_003, TestSize.Level0)
938 {
939 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_003 enter");
940 string appid = "granttest3";
941 vector<string> uris;
942 vector<string> inColumn;
943 for (int i = 0; i < 5; i++) {
944 string struri = CreateFile(MEDIALIBRARY_AUDIO_URI, "Audios/", "Test" + to_string(audioIndex++) + ".mp3",
945 MEDIA_TYPE_AUDIO, FILE_CONTENT_MP3);
946 inColumn.push_back(MediaFileUtils::GetIdFromUri(struri));
947 uris.push_back(struri);
948 }
949 auto permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
950 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
951 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
952 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryAudioResult;
953 QueryUriPermissionResult(appid, inColumn, TYPE_AUDIOS, queryAudioResult);
954 ASSERT_NE(queryAudioResult->GoToFirstRow(), E_OK);
955 do {
956 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryAudioResult);
957 EXPECT_NE(permissionType, static_cast<int32_t>(PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO));
958 } while (!queryAudioResult->GoToNextRow());
959
960 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_003 exit");
961 }
962
963 /**
964 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_004
965 * @tc.name : grant photo 、vidio and audio type mixed uris of permissions
966 * @tc.desc : check database grant results whether match
967 */
968 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_004, TestSize.Level0)
969 {
970 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_004 enter");
971 string appid = "granttest4";
972 vector<string> photoUris;
973 vector<string> vedioUris;
974 vector<string> audioUris;
975 vector<string> photoInColumn;
976 vector<string> vedioInColumn;
977 vector<string> audioInColumn;
978 for (int i = 0; i < 5; i++) {
979 auto photoUri = CreatePhotoAsset("test.jpg");
980 auto vedioUri = CreatePhotoAsset("test.mp4");
981 string audioUri = CreateFile(MEDIALIBRARY_AUDIO_URI, "Audios/", "Test" + to_string(audioIndex++) + ".mp3",
982 MEDIA_TYPE_AUDIO, FILE_CONTENT_MP3);
983 photoUris.push_back(photoUri);
984 vedioUris.push_back(vedioUri);
985 audioUris.push_back(audioUri);
986 photoInColumn.push_back(MediaFileUtils::GetIdFromUri(photoUri));
987 vedioInColumn.push_back(MediaFileUtils::GetIdFromUri(vedioUri));
988 audioInColumn.push_back(MediaFileUtils::GetIdFromUri(audioUri));
989 }
990 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
991 mediaLibraryManager->GrantPhotoUriPermission(appid, photoUris, permissionType, HideSensitiveType::NO_DESENSITIZE);
992 permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
993 mediaLibraryManager->GrantPhotoUriPermission(appid, vedioUris, permissionType, HideSensitiveType::NO_DESENSITIZE);
994 permissionType = PhotoPermissionType::TEMPORARY_READWRITE_IMAGEVIDEO;
995 mediaLibraryManager->GrantPhotoUriPermission(appid, audioUris, permissionType, HideSensitiveType::NO_DESENSITIZE);
996 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
997 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryVedioResult;
998 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryAudioResult;
999 QueryUriPermissionResult(appid, photoInColumn, TYPE_PHOTOS, queryPhotoResult);
1000 QueryUriPermissionResult(appid, vedioInColumn, TYPE_PHOTOS, queryVedioResult);
1001 QueryUriPermissionResult(appid, audioInColumn, TYPE_AUDIOS, queryAudioResult);
1002 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
1003 ASSERT_NE(queryVedioResult->GoToFirstRow(), E_OK);
1004 do {
1005 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryPhotoResult);
1006 EXPECT_EQ(permissionType, static_cast<int32_t>(PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO));
1007 } while (!queryPhotoResult->GoToNextRow());
1008 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_004 exit");
1009 }
1010
1011 /**
1012 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_005
1013 * @tc.name : same type but different uri grant different permissions
1014 * @tc.desc : check database grant results whether match
1015 */
1016 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_005, TestSize.Level0)
1017 {
1018 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_005 enter");
1019 string appid = "granttest5";
1020 vector<string> uris;
1021 vector<string> uris1;
1022 vector<string> uris2;
1023 vector<string> uris3;
1024 vector<string> uris4;
1025 vector<string> inColumn;
1026 vector<int32_t> expectResult;
1027 for (int i = 0; i < 20; i++) {
1028 auto uriStr = CreatePhotoAsset("test.jpg");
1029 inColumn.push_back(MediaFileUtils::GetIdFromUri(uriStr));
1030 uris.push_back(uriStr);
1031 }
1032 uris1.assign(uris.begin(), uris.begin()+5);
1033 uris2.assign(uris.begin()+5, uris.begin()+10);
1034 uris3.assign(uris.begin()+10, uris.begin()+15);
1035 uris4.assign(uris.begin()+15, uris.begin()+20);
1036 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1037 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1038 mediaLibraryManager->GrantPhotoUriPermission(appid, uris1, permissionType, SensitiveType);
1039 expectResult.insert(expectResult.begin(), 5, 0);
1040
1041 permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
1042 mediaLibraryManager->GrantPhotoUriPermission(appid, uris2, permissionType, SensitiveType);
1043 expectResult.insert(expectResult.end(), 5, 2);
1044
1045 permissionType = PhotoPermissionType::TEMPORARY_READWRITE_IMAGEVIDEO;
1046 mediaLibraryManager->GrantPhotoUriPermission(appid, uris4, permissionType, SensitiveType);
1047 expectResult.insert(expectResult.end(), 5, 3);
1048
1049 vector<int32_t>::iterator it = expectResult.begin();
1050 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
1051 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryPhotoResult);
1052 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
1053 do {
1054 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryPhotoResult);
1055 EXPECT_EQ(*it++, permissionType);
1056 } while (!queryPhotoResult->GoToNextRow());
1057 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_005 exit");
1058 }
1059
1060 /**
1061 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_006
1062 * @tc.name : same type but different uri grant random permissions
1063 * @tc.desc : check database grant results whether match
1064 */
1065 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_006, TestSize.Level0)
1066 {
1067 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_006 enter");
1068 string appid = "granttest6";
1069 vector<string> uris;
1070 vector<string> inColumn;
1071 vector<int32_t> expectResult;
1072 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1073 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1074 for (int i = 0; i < 20; i++) {
1075 auto uri = CreatePhotoAsset("test.jpg");
1076 inColumn.push_back(MediaFileUtils::GetIdFromUri(uri));
1077 vector<string> Tempuris{uri};
1078 uris.push_back(uri);
1079 permissionType = GetRandomTemporaryPermission();
1080 expectResult.push_back(static_cast<int32_t>(permissionType));
1081 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1082 }
1083 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
1084 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryPhotoResult);
1085 vector<int32_t>::iterator it = expectResult.begin();
1086 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
1087 do {
1088 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryPhotoResult);
1089 EXPECT_NE(*it++, permissionType);
1090 } while (!queryPhotoResult->GoToNextRow());
1091 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_006 exit");
1092 }
1093
1094 /**
1095 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_007
1096 * @tc.name : grand file type do not match
1097 * @tc.desc : check error result
1098 */
1099 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_007, TestSize.Level0)
1100 {
1101 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_007 enter");
1102 string appid = "granttest7";
1103 vector<string> uris;
1104 for (int i = 0; i < 5; i++) {
1105 auto uri = CreateFile(MEDIALIBRARY_FILE_URI, "Docs/Documents/", "Test" + to_string(txtIndex++) + ".txt",
1106 MEDIA_TYPE_FILE, FILE_CONTENT_TXT);
1107 uris.push_back(uri);
1108 }
1109 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1110 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1111 auto ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1112 ASSERT_EQ(ret, E_ERR);
1113 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_007 exit");
1114 }
1115
1116 /**
1117 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_008
1118 * @tc.name : uri number are over size
1119 * @tc.desc : check error result
1120 */
1121 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_008, TestSize.Level0)
1122 {
1123 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_008 enter");
1124 string appid = "granttest8";
1125 vector<string> uris;
1126 uris.resize(1001);
1127 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1128 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1129 auto ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1130 ASSERT_EQ(ret, E_ERR);
1131 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_008 exit");
1132 }
1133
1134 /**
1135 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_009
1136 * @tc.name : All uris are grant permission and then grant other permissions
1137 * @tc.desc : check database grant results whether match
1138 */
1139 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_009, TestSize.Level0)
1140 {
1141 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_009 enter");
1142 string appid = "granttest9";
1143 vector<string> uris;
1144 vector<string> uris1;
1145 vector<string> uris2;
1146 vector<string> uris3;
1147 vector<string> uris4;
1148 vector<string> inColumn;
1149 vector<int32_t> expectResult;
1150 for (int i = 0; i < 20; i++) {
1151 auto uriStr = CreatePhotoAsset("test.jpg");
1152 uris.push_back(uriStr);
1153 inColumn.push_back(MediaFileUtils::GetIdFromUri(uriStr));
1154 }
1155 uris1.assign(uris.begin(), uris.begin()+5);
1156 uris2.assign(uris.begin()+5, uris.begin()+10);
1157 uris3.assign(uris.begin()+10, uris.begin()+15);
1158 uris4.assign(uris.begin()+15, uris.begin()+20);
1159 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1160 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1161 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1162
1163 permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1164 mediaLibraryManager->GrantPhotoUriPermission(appid, uris1, permissionType, SensitiveType);
1165 expectResult.insert(expectResult.begin(), 5, 0);
1166 permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
1167 mediaLibraryManager->GrantPhotoUriPermission(appid, uris2, permissionType, SensitiveType);
1168 expectResult.insert(expectResult.end(), 5, 2);
1169 permissionType = PhotoPermissionType::TEMPORARY_READWRITE_IMAGEVIDEO;
1170 mediaLibraryManager->GrantPhotoUriPermission(appid, uris3, permissionType, SensitiveType);
1171 expectResult.insert(expectResult.end(), 5, 3);
1172 mediaLibraryManager->GrantPhotoUriPermission(appid, uris4, permissionType, SensitiveType);
1173 expectResult.insert(expectResult.end(), 5, 3);
1174
1175 vector<int32_t>::iterator it = expectResult.begin();
1176 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
1177 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryPhotoResult);
1178 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
1179 do {
1180 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryPhotoResult);
1181 EXPECT_EQ(*it++, permissionType);
1182 } while (!queryPhotoResult->GoToNextRow());
1183 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_009 exit");
1184 }
1185
1186 /**
1187 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_010
1188 * @tc.name : All uris are grant rand permission and then grant a same permission type
1189 * @tc.desc : check database grant results whether match
1190 */
1191 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_010, TestSize.Level0)
1192 {
1193 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_010 enter");
1194 string appid = "granttest10";
1195 vector<string> uris;
1196 vector<string> inColumn;
1197 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1198 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1199 for (int i = 0; i < 20; i++) {
1200 auto uri = CreatePhotoAsset("test.jpg");
1201 string fileId = MediaFileUtils::GetIdFromUri(uri);
1202 inColumn.push_back(fileId);
1203 vector<string> Tempuris{uri};
1204 uris.push_back(uri);
1205 permissionType = GetRandomTemporaryPermission();
1206 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1207 }
1208 permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
1209 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1210 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
1211 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryPhotoResult);
1212 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
1213 do {
1214 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryPhotoResult);
1215 EXPECT_NE(permissionType, static_cast<int32_t>(PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO));
1216 } while (!queryPhotoResult->GoToNextRow());
1217 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_010 exit");
1218 }
1219
1220 /**
1221 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_011
1222 * @tc.name : grant uris serial times of permission
1223 * @tc.desc : check database grant results whether match
1224 */
1225 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_011, TestSize.Level0)
1226 {
1227 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_011 enter");
1228 string appid = "granttest11";
1229 vector<string> uris;
1230 vector<string> inColumn;
1231 for (int i = 0; i < 10; i++) {
1232 string uri = CreateOwnerPrivliegeAssets(appid);
1233 uris.push_back(uri);
1234 inColumn.push_back(MediaFileUtils::GetIdFromUri(uri));
1235 }
1236 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1237 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1238 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1239 permissionType = PhotoPermissionType::PERSIST_READ_IMAGEVIDEO;
1240 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1241 permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
1242 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1243 permissionType = PhotoPermissionType::TEMPORARY_READWRITE_IMAGEVIDEO;
1244 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1245
1246 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
1247 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryPhotoResult);
1248 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
1249 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_011 exit");
1250 }
1251
1252 /**
1253 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_012
1254 * @tc.name : uris are mix with all grant permissions
1255 * @tc.desc : check database grant results whether match
1256 */
1257 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_012, TestSize.Level0)
1258 {
1259 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_012 enter");
1260 string appid = "granttest12";
1261 vector<string> uris;
1262 vector<string> photosInColumn;
1263 vector<string> previliegeInColumn;
1264 auto permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
1265 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1266 for (int i = 0; i < 10; i++) {
1267 string previlegeUri = CreateOwnerPrivliegeAssets(appid);
1268 auto photouri = CreatePhotoAsset("test.jpg");
1269 uris.push_back(previlegeUri);
1270 uris.push_back(photouri);
1271 previliegeInColumn.push_back(MediaFileUtils::GetIdFromUri(previlegeUri));
1272 photosInColumn.push_back(MediaFileUtils::GetIdFromUri(photouri));
1273 vector<string> Tempuris{photouri};
1274 permissionType = GetRandomTemporaryPermission();
1275 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1276 }
1277 permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
1278 mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1279 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPhotoResult;
1280 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryPreviliegeResult;
1281 QueryUriPermissionResult(appid, photosInColumn, TYPE_PHOTOS, queryPhotoResult);
1282 QueryUriPermissionResult(appid, previliegeInColumn, TYPE_PHOTOS, queryPreviliegeResult);
1283 ASSERT_NE(queryPhotoResult->GoToFirstRow(), E_OK);
1284 ASSERT_NE(queryPreviliegeResult->GoToFirstRow(), E_OK);
1285 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_012 exit");
1286 }
1287
1288 /**
1289 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_013
1290 * @tc.name : permissionType error
1291 * @tc.desc : check error result
1292 */
1293 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_013, TestSize.Level0)
1294 {
1295 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_013 enter");
1296 string appid = "granttest13";
1297 vector<string> uris;
1298 for (int i = 0; i < 5; i++) {
1299 string uri = CreateOwnerPrivliegeAssets(appid);
1300 uris.push_back(uri);
1301 }
1302 auto permissionType = PhotoPermissionType::PERSIST_READ_IMAGEVIDEO;
1303 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1304 auto ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1305 ASSERT_EQ(ret, E_ERR);
1306 permissionType = static_cast<PhotoPermissionType>(4);
1307 ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1308 ASSERT_EQ(ret, E_ERR);
1309 permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1310 ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1311 ASSERT_EQ(ret, E_SUCCESS);
1312 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_013 exit");
1313 }
1314
1315 /**
1316 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_014
1317 * @tc.name : HideSensitiveType Error
1318 * @tc.desc : check error result
1319 */
1320 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_014, TestSize.Level0)
1321 {
1322 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_014 enter");
1323 string appid = "granttest14";
1324 vector<string> uris;
1325 for (int i = 0; i < 5; i++) {
1326 string uri = CreateOwnerPrivliegeAssets(appid);
1327 uris.push_back(uri);
1328 }
1329 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1330 auto SensitiveType = static_cast<HideSensitiveType>(-1);
1331 auto ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1332 ASSERT_EQ(ret, E_ERR);
1333 SensitiveType = static_cast<HideSensitiveType>(4);
1334 ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1335 ASSERT_EQ(ret, E_ERR);
1336 SensitiveType = HideSensitiveType::ALL_DESENSITIZE;
1337 ret = mediaLibraryManager->GrantPhotoUriPermission(appid, uris, permissionType, SensitiveType);
1338 ASSERT_EQ(ret, E_SUCCESS);
1339 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_014 exit");
1340 }
1341
1342 /**
1343 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_015
1344 * @tc.name : Filter not exist photo uri
1345 * @tc.desc : check database grant results whether match
1346 */
1347 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_015, TestSize.Level0)
1348 {
1349 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_015 enter");
1350 string appid = "granttest15";
1351 vector<string> Uris;
1352 vector<string> inColumn;
1353 for (int i = 0; i < 10; i++) {
1354 string photosUri = CreatePhotoAsset("test.jpg");
1355 string existUri = CreatePhotoAsset("test2.jpg");
1356 DeletAssetInDb(photosUri, TYPE_PHOTOS);
1357 Uris.push_back(photosUri);
1358 Uris.push_back(existUri);
1359 inColumn.push_back(MediaFileUtils::GetIdFromUri(photosUri));
1360 inColumn.push_back(MediaFileUtils::GetIdFromUri(existUri));
1361 }
1362 auto permissionType = PhotoPermissionType::TEMPORARY_WRITE_IMAGEVIDEO;
1363 auto SensitiveType = HideSensitiveType::ALL_DESENSITIZE;
1364 mediaLibraryManager->GrantPhotoUriPermission(appid, Uris, permissionType, SensitiveType);
1365
1366 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryResult;
1367 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryResult);
1368 ASSERT_NE(queryResult->GoToFirstRow(), E_OK);
1369 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_015 exit");
1370 }
1371
1372 /**
1373 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_016
1374 * @tc.name : Filter not exist audio uri
1375 * @tc.desc : check database grant results whether match
1376 */
1377 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_016, TestSize.Level0)
1378 {
1379 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_016 enter");
1380 string appid = "granttest16";
1381 vector<string> Uris;
1382 vector<string> inColumn;
1383 for (int i = 0; i < 10; i++) {
1384 string audiosUri = CreateFile(MEDIALIBRARY_AUDIO_URI, "Audios/", "Test" + to_string(audioIndex++) + ".mp3",
1385 MEDIA_TYPE_AUDIO, FILE_CONTENT_MP3);
1386 string audiosExistUri = CreateFile(MEDIALIBRARY_AUDIO_URI, "Audios/", "Test" + to_string(audioIndex++) + ".mp3",
1387 MEDIA_TYPE_AUDIO, FILE_CONTENT_MP3);
1388 DeletAssetInDb(audiosUri, TYPE_AUDIOS);
1389 Uris.push_back(audiosExistUri);
1390 Uris.push_back(audiosUri);
1391 inColumn.push_back(MediaFileUtils::GetIdFromUri(audiosUri));
1392 inColumn.push_back(MediaFileUtils::GetIdFromUri(audiosExistUri));
1393 }
1394 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1395 auto SensitiveType = HideSensitiveType::ALL_DESENSITIZE;
1396 mediaLibraryManager->GrantPhotoUriPermission(appid, Uris, permissionType, SensitiveType);
1397
1398 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryResult;
1399 QueryUriPermissionResult(appid, inColumn, TYPE_AUDIOS, queryResult);
1400 ASSERT_NE(queryResult->GoToFirstRow(), E_OK);
1401 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_016 exit");
1402 }
1403
1404 /**
1405 * @tc.number : MediaLibraryManager_GrantPhotoUriPermission_test_017
1406 * @tc.name : Max uri number
1407 * @tc.desc : check database grant results whether match
1408 */
1409 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_GrantPhotoUriPermission_test_017, TestSize.Level0)
1410 {
1411 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_017 enter");
1412 string appid = "granttest17";
1413 vector<string> errorUris;
1414 vector<string> inColumn;
1415 int32_t resultCount = 0;
1416 string uri = CreatePhotoAsset("test.jpg");
1417 inColumn.push_back(MediaFileUtils::GetIdFromUri(uri));
1418 for (int i = 0; i < 1000; i++) {
1419 errorUris.push_back(uri);
1420 }
1421 auto permissionType = PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO;
1422 auto SensitiveType = HideSensitiveType::ALL_DESENSITIZE;
1423 auto ret = mediaLibraryManager->GrantPhotoUriPermission(appid, errorUris, permissionType, SensitiveType);
1424 ASSERT_EQ(ret, E_SUCCESS);
1425 std::shared_ptr<OHOS::DataShare::DataShareResultSet> queryResult;
1426 QueryUriPermissionResult(appid, inColumn, TYPE_PHOTOS, queryResult);
1427 ASSERT_NE(queryResult->GoToFirstRow(), E_OK);
1428 do {
1429 int32_t permissionType = GetInt32Val(AppUriPermissionColumn::PERMISSION_TYPE, queryResult);
1430 EXPECT_EQ(permissionType, static_cast<int32_t>(PhotoPermissionType::TEMPORARY_READ_IMAGEVIDEO));
1431 resultCount++;
1432 } while (!queryResult->GoToNextRow());
1433 ASSERT_EQ(resultCount, 1);
1434 MEDIA_INFO_LOG("MediaLibraryManager_GrantPhotoUriPermission_test_017 exit");
1435 }
1436
1437 /**
1438 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_001
1439 * @tc.name : Check only read system permission uri permission results
1440 * @tc.desc : Grant system read permission to see CheckPhotoUriPermission results
1441 */
1442 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_001, TestSize.Level0)
1443 {
1444 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_001 enter");
1445 string appid = "checktest1";
1446 vector<string> uris;
1447 vector<bool> resultSet;
1448 for (int i = 0; i < 10; i++) {
1449 auto uri = CreatePhotoAsset("test.jpg");
1450 uris.push_back(uri);
1451 }
1452 vector<string> perms;
1453 uint64_t tokenId = 0;
1454 perms.push_back("ohos.permission.READ_MEDIA");
1455 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
1456 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
1457 ASSERT_TRUE(tokenId != 0);
1458
1459 int32_t permissionFlag = 1;
1460 auto ret = mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1461 EXPECT_EQ(ret, E_SUCCESS);
1462 for (const auto res : resultSet) {
1463 EXPECT_EQ(res, true);
1464 }
1465 permissionFlag = 2;
1466 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1467 for (const auto res : resultSet) {
1468 EXPECT_EQ(res, false);
1469 }
1470 permissionFlag = 3;
1471 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1472 for (const auto res : resultSet) {
1473 EXPECT_EQ(res, false);
1474 }
1475 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_001 exit");
1476 }
1477
1478 /**
1479 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_002
1480 * @tc.name : Check has read and wirte system permission uri permission results
1481 * @tc.desc : Grant system read and write permission to see CheckPhotoUriPermission results
1482 */
1483 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_002, TestSize.Level0)
1484 {
1485 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_002 enter");
1486 string appid = "checktest2";
1487 vector<string> uris;
1488 vector<bool> resultSet;
1489 for (int i = 0; i < 10; i++) {
1490 auto uri = CreatePhotoAsset("test.jpg");
1491 uris.push_back(uri);
1492 }
1493 vector<string> perms;
1494 uint64_t tokenId = 0;
1495 perms.push_back("ohos.permission.READ_MEDIA");
1496 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
1497 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
1498 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
1499 ASSERT_TRUE(tokenId != 0);
1500
1501 uint32_t permissionFlag = 1;
1502 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1503 for (const auto res : resultSet) {
1504 EXPECT_EQ(res, true);
1505 }
1506 permissionFlag = 2;
1507 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1508 for (const auto res : resultSet) {
1509 EXPECT_EQ(res, true);
1510 }
1511 permissionFlag = 3;
1512 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1513 for (const auto res : resultSet) {
1514 EXPECT_EQ(res, true);
1515 }
1516 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_002 exit");
1517 }
1518 /**
1519 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_003
1520 * @tc.name : Check no system permission uri permission results
1521 * @tc.desc : No system permission and see CheckPhotoUriPermission check results
1522 */
1523 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_003, TestSize.Level0)
1524 {
1525 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_003 enter");
1526 vector<string> perms;
1527 uint64_t tokenId = 0;
1528 string appid = "checktest3";
1529 vector<string> uris;
1530 vector<bool> resultSet;
1531 for (int i = 0; i < 10; i++) {
1532 auto uriStr = CreatePhotoAsset("test.jpg");
1533 uris.push_back(uriStr);
1534 }
1535 uint32_t permissionFlag = 1;
1536 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1537 for (const auto res : resultSet) {
1538 EXPECT_EQ(res, false);
1539 }
1540 permissionFlag = 2;
1541 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1542 for (const auto res : resultSet) {
1543 EXPECT_EQ(res, false);
1544 }
1545 permissionFlag = 3;
1546 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1547 for (const auto res : resultSet) {
1548 EXPECT_EQ(res, false);
1549 }
1550 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_003 exit");
1551 }
1552
1553 /**
1554 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_004
1555 * @tc.name : Grant Audio system read permission
1556 * @tc.desc : Check uri permission results when has Audio system read permission
1557 */
1558 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_004, TestSize.Level0)
1559 {
1560 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_004 enter");
1561 vector<string> uris;
1562 string appid = "checktest4";
1563 vector<bool> resultSet;
1564 for (int i = 0; i < 10; i++) {
1565 string uri = CreateFile(MEDIALIBRARY_AUDIO_URI, "Audios/", "Test" + to_string(audioIndex++) + ".mp3",
1566 MEDIA_TYPE_AUDIO, FILE_CONTENT_MP3);
1567 uris.push_back(uri);
1568 }
1569 uint64_t tokenId = 0;
1570 vector<string> perms;
1571 perms.push_back("ohos.permission.READ_MEDIA");
1572 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
1573 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
1574 perms.push_back("ohos.permission.READ_AUDIO");
1575 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
1576 ASSERT_TRUE(tokenId != 0);
1577
1578 uint32_t permissionFlag = 1;
1579 auto ret = mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1580 EXPECT_EQ(ret, E_SUCCESS);
1581 for (const auto res : resultSet) {
1582 EXPECT_EQ(res, true);
1583 }
1584 permissionFlag = 2;
1585 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1586 for (const auto res : resultSet) {
1587 EXPECT_EQ(res, false);
1588 }
1589 permissionFlag = 3;
1590 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1591 for (const auto res : resultSet) {
1592 EXPECT_EQ(res, false);
1593 }
1594 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_004 exit");
1595 }
1596
1597 /**
1598 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_005
1599 * @tc.name : Grant Audio system write permission
1600 * @tc.desc : Check uri permission results when has Audio system wirte permission
1601 */
1602 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_005, TestSize.Level0)
1603 {
1604 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_005 enter");
1605 vector<string> uris;
1606 string appid = "checktest5";
1607 vector<bool> resultSet;
1608 for (int i = 0; i < 10; i++) {
1609 string uri = CreateFile(MEDIALIBRARY_AUDIO_URI, "Audios/", "Test" + to_string(audioIndex++) + ".mp3",
1610 MEDIA_TYPE_AUDIO, FILE_CONTENT_MP3);
1611 uris.push_back(uri);
1612 }
1613 uint64_t tokenId = 0;
1614 vector<string> perms;
1615 perms.push_back("ohos.permission.READ_MEDIA");
1616 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
1617 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
1618 perms.push_back("ohos.permission.WRITE_AUDIO");
1619 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
1620 ASSERT_TRUE(tokenId != 0);
1621
1622 uint32_t permissionFlag = 1;
1623 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1624 for (const auto res : resultSet) {
1625 EXPECT_EQ(res, true);
1626 }
1627 permissionFlag = 2;
1628 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1629 for (const auto res : resultSet) {
1630 EXPECT_EQ(res, true);
1631 }
1632 permissionFlag = 3;
1633 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1634 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_005 exit");
1635 }
1636
1637 /**
1638 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_006
1639 * @tc.name : Grant Audio system read and write permission
1640 * @tc.desc : Check uri permission results when has Audio system read and wirte permission
1641 */
1642 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_006, TestSize.Level0)
1643 {
1644 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_006 enter");
1645 vector<string> uris;
1646 string appid = "checktest6";
1647 vector<bool> resultSet;
1648 for (int i = 0; i < 10; i++) {
1649 string uri = CreateFile(MEDIALIBRARY_AUDIO_URI, "Audios/", "Test" + to_string(audioIndex++) + ".mp3",
1650 MEDIA_TYPE_AUDIO, FILE_CONTENT_MP3);
1651 uris.push_back(uri);
1652 }
1653 uint64_t tokenId = 0;
1654 vector<string> perms;
1655 perms.push_back("ohos.permission.READ_MEDIA");
1656 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
1657 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
1658 perms.push_back("ohos.permission.READ_AUDIO");
1659 perms.push_back("ohos.permission.WRITE_AUDIO");
1660 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
1661 ASSERT_TRUE(tokenId != 0);
1662
1663 uint32_t permissionFlag = 1;
1664 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1665 for (const auto res : resultSet) {
1666 EXPECT_EQ(res, true);
1667 }
1668 permissionFlag = 2;
1669 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1670 for (const auto res : resultSet) {
1671 EXPECT_EQ(res, true);
1672 }
1673 permissionFlag = 3;
1674 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1675 for (const auto res : resultSet) {
1676 EXPECT_EQ(res, true);
1677 }
1678 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_006 exit");
1679 }
1680
1681 /**
1682 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_007
1683 * @tc.name : Has no system permissions but all uri have grant other permissions
1684 * @tc.desc : Check uri permissions results when all uri have grant other permissions
1685 */
1686 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_007, TestSize.Level0)
1687 {
1688 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_007 enter");
1689 vector<string> perms;
1690 uint64_t tokenId = 0;
1691 string appid = "checktest7";
1692 vector<string> uris;
1693 vector<bool> resultSet;
1694 vector<bool> expectReadResult;
1695 vector<bool> expectWriteResult;
1696 vector<bool> expectReadWriteResult;
1697 auto permissionType = PhotoPermissionType::PERSIST_READ_IMAGEVIDEO;
1698 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1699 for (int i = 0; i < 20; i++) {
1700 string uri = CreatePhotoAsset("test.jpg");
1701 vector<string> Tempuris{uri};
1702 uris.push_back(uri);
1703 permissionType = GetRandomTemporaryPermission();
1704 if (static_cast<int32_t>(permissionType) == 0) {
1705 expectReadResult.push_back(true);
1706 expectWriteResult.push_back(false);
1707 expectReadWriteResult.push_back(false);
1708 } else if (static_cast<int32_t>(permissionType) == 2) {
1709 expectReadResult.push_back(true);
1710 expectWriteResult.push_back(true);
1711 expectReadWriteResult.push_back(false);
1712 } else {
1713 expectReadResult.push_back(true);
1714 expectWriteResult.push_back(true);
1715 expectReadWriteResult.push_back(true);
1716 }
1717 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1718 }
1719 uint32_t permissionFlag = 1;
1720 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1721 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_007 exit");
1722 }
1723
1724 /**
1725 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_008
1726 * @tc.name : Has no system permissions but part of uri have grant other permissions
1727 * @tc.desc : Check uri permissions results when part of have grant other permissions
1728 */
1729 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_008, TestSize.Level0)
1730 {
1731 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_008 enter");
1732 vector<string> perms;
1733 string appid = "checktest8";
1734 vector<string> uris;
1735 vector<bool> resultSet;
1736 vector<vector<bool>> expectResult;
1737 expectResult.resize(3);
1738 auto permissionType = PhotoPermissionType::PERSIST_READ_IMAGEVIDEO;
1739 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1740 for (int i = 0; i < 10; i++) {
1741 auto uri = CreatePhotoAsset("test.jpg");
1742 vector<string> Tempuris{uri};
1743 uris.push_back(uri);
1744 permissionType = GetRandomTemporaryPermission();
1745 if (static_cast<int32_t>(permissionType) == 0) {
1746 expectResult[0].push_back(true);
1747 expectResult[1].push_back(false);
1748 expectResult[2].push_back(false);
1749 } else if (static_cast<int32_t>(permissionType) == 2) {
1750 expectResult[0].push_back(false);
1751 expectResult[1].push_back(true);
1752 expectResult[2].push_back(false);
1753 } else {
1754 expectResult[0].push_back(true);
1755 expectResult[1].push_back(true);
1756 expectResult[2].push_back(true);
1757 }
1758 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1759 }
1760 for (int i = 0; i < 5; i++) {
1761 uris.push_back(CreatePhotoAsset("test.jpg"));
1762 expectResult[0].push_back(false);
1763 expectResult[1].push_back(false);
1764 expectResult[2].push_back(false);
1765 }
1766 }
1767
1768 /**
1769 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_009
1770 * @tc.name : Has read system permissions and also uri have grant other permissions
1771 * @tc.desc : Check uri permissions results when has system read permission and other permission
1772 */
1773 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_009, TestSize.Level0)
1774 {
1775 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_009 enter");
1776 string appid = "checktest9";
1777 vector<string> uris;
1778 vector<bool> resultSet;
1779 vector<bool> expectWriteResult;
1780 vector<bool> expectReadWriteResult;
1781 auto permissionType = PhotoPermissionType::PERSIST_READ_IMAGEVIDEO;
1782 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1783 for (int i = 0; i < 10; i++) {
1784 string uri = CreatePhotoAsset("test.jpg");
1785 vector<string> Tempuris{uri};
1786 uris.push_back(uri);
1787 permissionType = GetRandomTemporaryPermission();
1788 if (static_cast<int32_t>(permissionType) == 0) {
1789 expectWriteResult.push_back(true);
1790 expectReadWriteResult.push_back(false);
1791 } else if (static_cast<int32_t>(permissionType) == 2) {
1792 expectWriteResult.push_back(true);
1793 expectReadWriteResult.push_back(true);
1794 } else {
1795 expectWriteResult.push_back(true);
1796 expectReadWriteResult.push_back(true);
1797 }
1798 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1799 }
1800 uint64_t tokenId = 0;
1801 vector<string> perms;
1802 perms.push_back("ohos.permission.READ_MEDIA");
1803 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
1804 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
1805 ASSERT_TRUE(tokenId != 0);
1806
1807 uint32_t permissionFlag = 1;
1808 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1809 for (int i = 0; i < resultSet.size(); i++) {
1810 EXPECT_EQ(resultSet[i], true);
1811 }
1812 permissionFlag = 2;
1813 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1814 permissionFlag = 3;
1815 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1816 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_009 exit");
1817 }
1818
1819
1820 /**
1821 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_010
1822 * @tc.name : Has read and write system permissions and also uri have grant other permissions
1823 * @tc.desc : Check uri permissions results when has system read and write permission and other permissions
1824 */
1825 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_010, TestSize.Level0)
1826 {
1827 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_010 enter");
1828 string appid = "checktest10";
1829 vector<string> uris;
1830 vector<bool> resultSet;
1831 auto permissionType = PhotoPermissionType::PERSIST_READ_IMAGEVIDEO;
1832 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1833 for (int i = 0; i < 10; i++) {
1834 string uri = CreatePhotoAsset("test.jpg");
1835 vector<string> Tempuris{uri};
1836 uris.push_back(uri);
1837 permissionType = GetRandomTemporaryPermission();
1838 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1839 }
1840 uint64_t tokenId = 0;
1841 vector<string> perms;
1842 perms.push_back("ohos.permission.READ_MEDIA");
1843 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
1844 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
1845 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId);
1846 ASSERT_TRUE(tokenId != 0);
1847
1848 int32_t permissionFlag = 1;
1849 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1850 for (int i = 0; i < resultSet.size(); i++) {
1851 EXPECT_EQ(resultSet[i], true);
1852 }
1853 permissionFlag = 2;
1854 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1855 for (int i = 0; i < resultSet.size(); i++) {
1856 EXPECT_EQ(resultSet[i], true);
1857 }
1858 permissionFlag = 3;
1859 mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1860 for (int i = 0; i < resultSet.size(); i++) {
1861 EXPECT_EQ(resultSet[i], true);
1862 }
1863 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_0010 exit");
1864 }
1865
1866 /**
1867 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_011
1868 * @tc.name : uri numuber are oversize
1869 * @tc.desc : check error result
1870 */
1871 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_011, TestSize.Level0)
1872 {
1873 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_011 enter");
1874 ASSERT_TRUE(tokenId != 0);
1875 tokenId = 0;
1876 vector<string> uris;
1877 string appid = "checktest11";
1878 vector<bool> resultSet;
1879 uint32_t permissionFlag = 1;
1880 uris.resize(1001);
1881 auto ret = mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1882 EXPECT_EQ(ret, E_ERR);
1883 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_011 exit");
1884 }
1885
1886 /**
1887 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_012
1888 * @tc.name : file type do not match
1889 * @tc.desc : check error result
1890 */
1891 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_012, TestSize.Level0)
1892 {
1893 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_012 enter");
1894 ASSERT_TRUE(tokenId != 0);
1895 tokenId = 0;
1896 vector<string> uris;
1897 string appid = "checktest12";
1898 vector<bool> resultSet;
1899 uint32_t permissionFlag = 1;
1900 for (int i = 0; i < 5; i++) {
1901 string uri = CreateFile(MEDIALIBRARY_FILE_URI, "Docs/Documents/", "Test" + to_string(txtIndex++) + ".txt",
1902 MEDIA_TYPE_FILE, FILE_CONTENT_TXT);
1903 uris.push_back(uri);
1904 }
1905 auto ret = mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1906 EXPECT_EQ(ret, E_ERR);
1907 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_012 exit");
1908 }
1909
1910 /**
1911 * @tc.number : MediaLibraryManager_CheckPhotoUriPermission_test_013
1912 * @tc.name : file check flag do not match
1913 * @tc.desc : check error result
1914 */
1915 HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_CheckPhotoUriPermission_test_013, TestSize.Level0)
1916 {
1917 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_013 enter");
1918 ASSERT_TRUE(tokenId != 0);
1919 tokenId = 0;
1920 vector<string> uris;
1921 string appid = "checktest13";
1922 vector<bool> resultSet;
1923 auto permissionType = PhotoPermissionType::PERSIST_READ_IMAGEVIDEO;
1924 auto SensitiveType = HideSensitiveType::GEOGRAPHIC_LOCATION_DESENSITIZE;
1925 uint32_t permissionFlag = 0;
1926 for (int i = 0; i < 5; i++) {
1927 string uri = CreatePhotoAsset("test.jpg");
1928 vector<string> Tempuris{uri};
1929 uris.push_back(uri);
1930 permissionType = GetRandomTemporaryPermission();
1931 mediaLibraryManager->GrantPhotoUriPermission(appid, Tempuris, permissionType, SensitiveType);
1932 }
1933 auto ret = mediaLibraryManager->CheckPhotoUriPermission(tokenId, appid, uris, resultSet, permissionFlag);
1934 EXPECT_EQ(ret, E_ERR);
1935 MEDIA_INFO_LOG("MediaLibraryManager_CheckPhotoUriPermission_test_013 exit");
1936 }
1937 } // namespace Media
1938 } // namespace OHOS
1939
