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 #define MLOG_TAG "BackupTest"
17
18 #include "medialibrary_backup_test.h"
19
20 #include <sys/stat.h>
21 #include <sys/types.h>
22 #include <utime.h>
23
24 #define private public
25 #define protected public
26 #include "backup_const_column.h"
27 #include "backup_const_map.h"
28 #include "backup_database_utils.h"
29 #include "backup_file_utils.h"
30 #include "external_source.h"
31 #include "gallery_source.h"
32 #include "media_log.h"
33 #include "upgrade_restore.h"
34 #include "media_file_utils.h"
35 #include "parameters.h"
36 #include "cloud_sync_manager.h"
37 #include "medialibrary_errno.h"
38 #include "medialibrary_rdb_utils.h"
39 #include "medialibrary_unistore_manager.h"
40 #include "medialibrary_unittest_utils.h"
41 #include "vision_db_sqls.h"
42 #undef private
43 #undef protected
44 #include "mimetype_utils.h"
45
46 using namespace std;
47 using namespace OHOS;
48 using namespace testing::ext;
49 using namespace OHOS::NativeRdb;
50
51 namespace OHOS {
52 namespace Media {
53 const std::string TEST_BACKUP_PATH = "/data/test/backup/db";
54 const std::string TEST_UPGRADE_FILE_DIR = "/data/test/backup/file";
55 const std::string GALLERY_APP_NAME = "gallery";
56 const std::string MEDIA_APP_NAME = "external";
57 const std::string MEDIA_LIBRARY_APP_NAME = "medialibrary";
58 const std::string TEST_PATH_PREFIX = "/TestPrefix";
59 const std::string TEST_RELATIVE_PATH = "/Pictures/Test/test.jpg";
60 const std::string TEST_CLOUD_PATH_PREFIX = "/storage/cloud/files/Photo/1/";
61
62 const int EXPECTED_NUM = 34;
63 const int EXPECTED_OREINTATION = 270;
64 const int TEST_LOCAL_MEDIA_ID = 12345;
65 const int TEST_PREFIX_LEVEL = 4;
66 const int TEST_SIZE_MIN = 1080;
67 const int TEST_SIZE_MAX = 2560;
68 const int TEST_SIZE_INCR_UNIT = 100;
69 const int TEST_SIZE_MULT_UNIT = 2;
70 const int TEST_PORTRAIT_ALBUM_COUNT = 2;
71 const int TEST_PORTRAIT_TAG_COUNT = 3;
72 const int TEST_PORTRAIT_PHOTO_COUNT = 3;
73 const int TEST_PORTRAIT_FACE_COUNT = 4;
74 const float TEST_SCALE_MIN = 0.2;
75 const float TEST_SCALE_MAX = 0.8;
76 const float TEST_LANDMARK_BELOW = 0.1;
77 const float TEST_LANDMARK_BETWEEN = 0.5;
78 const float TEST_LANDMARK_ABOVE = 0.9;
79 const std::string EXPECTED_PACKAGE_NAME = "wechat";
80 const std::string EXPECTED_USER_COMMENT = "user_comment";
81 const int64_t EXPECTED_DATE_ADDED = 1495970415378;
82 const int64_t EXPECTED_DATE_TAKEN = 1495970415379;
83 const std::string EXPECTED_DETAIL_TIME = "2024:09:06 17:00:01";
84 const int64_t TEST_TRUE_MEDIAID = 1;
85 const int64_t TEST_FALSE_MEDIAID = -1;
86 const int64_t TEST_SIZE_2MB = 2 * 1024 * 1024;
87 const int64_t TEST_SIZE_2MB_BELOW = TEST_SIZE_2MB - 1;
88 const int64_t TEST_SIZE_2MB_ABOVE = TEST_SIZE_2MB + 1;
89 const vector<string> CLEAR_SQLS = {
90 "DELETE FROM " + PhotoColumn::PHOTOS_TABLE,
91 "DELETE FROM " + PhotoAlbumColumns::TABLE + " WHERE " + PhotoAlbumColumns::ALBUM_TYPE + " != " +
92 to_string(PhotoAlbumType::SYSTEM),
93 "DELETE FROM " + PhotoMap::TABLE,
94 "DELETE FROM " + ANALYSIS_ALBUM_TABLE + " WHERE " + PhotoAlbumColumns::ALBUM_SUBTYPE + " != " +
95 to_string(PhotoAlbumSubType::SHOOTING_MODE),
96 "DELETE FROM " + ANALYSIS_PHOTO_MAP_TABLE,
97 "DELETE FROM " + AudioColumn::AUDIOS_TABLE,
98 "DELETE FROM tab_analysis_image_face",
99 "DELETE FROM tab_analysis_face_tag",
100 "DELETE FROM tab_analysis_total",
101 CREATE_VISION_INSERT_TRIGGER_FOR_ONCREATE,
102 };
103
104 const string PhotosOpenCall::CREATE_PHOTOS = string("CREATE TABLE IF NOT EXISTS Photos ") +
105 " (file_id INTEGER PRIMARY KEY AUTOINCREMENT, data TEXT, title TEXT, display_name TEXT, size BIGINT," +
106 " media_type INT, date_added BIGINT, date_taken BIGINT, duration INT, is_favorite INT default 0, " +
107 " date_trashed BIGINT DEFAULT 0, hidden INT DEFAULT 0, height INT, width INT, user_comment TEXT, " +
108 " orientation INT DEFAULT 0, package_name TEXT, burst_cover_level INT DEFAULT 1, burst_key TEXT, " +
109 " dirty INTEGER DEFAULT 0, subtype INT, detail_time TEXT);";
110
111 const string PhotosOpenCall::CREATE_PHOTOS_ALBUM = "CREATE TABLE IF NOT EXISTS PhotoAlbum \
112 (album_id INTEGER PRIMARY KEY AUTOINCREMENT, album_type INT, \
113 album_subtype INT, album_name TEXT COLLATE NOCASE, cover_uri TEXT, count \
114 INT DEFAULT 0, date_modified BIGINT DEFAULT 0, dirty INT DEFAULT 1 , cloud_id TEXT, \
115 relative_path TEXT, contains_hidden INT DEFAULT 0, hidden_count INT DEFAULT 0, \
116 hidden_cover TEXT DEFAULT '', album_order INT, image_count INT DEFAULT 0, \
117 video_count INT DEFAULT 0, bundle_name TEXT, local_language TEXT, \
118 is_local INT)";
119
120 const string PhotosOpenCall::CREATE_PHOTOS_MAP = "CREATE TABLE IF NOT EXISTS PhotoMap \
121 (map_album INT, map_asset INT, dirty INT DEFAULT 1, PRIMARY KEY (map_album, map_asset))";
122
OnCreate(RdbStore & store)123 int PhotosOpenCall::OnCreate(RdbStore &store)
124 {
125 int ret = 0;
126 ret += store.ExecuteSql(CREATE_PHOTOS);
127 ret += store.ExecuteSql(CREATE_PHOTOS_ALBUM);
128 ret += store.ExecuteSql(CREATE_PHOTOS_MAP);
129 return ret;
130 }
131
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)132 int PhotosOpenCall::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
133 {
134 return 0;
135 }
136
137 std::shared_ptr<NativeRdb::RdbStore> photosStorePtr = nullptr;
138 std::unique_ptr<UpgradeRestore> restoreService = nullptr;
139
InitPhotoAlbum()140 void InitPhotoAlbum()
141 {
142 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
143 VALUES (0, 1, 'test101');");
144 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
145 VALUES (1024, 2049, 'TmallPic');");
146 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
147 VALUES (1024, 2049, '美图贴贴');");
148 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
149 VALUES (1024, 2049, 'funnygallery');");
150 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
151 VALUES (1024, 2049, 'xiaohongshu');");
152 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
153 VALUES (1024, 2049, 'Douyin');");
154 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
155 VALUES (1024, 2049, 'save');");
156 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
157 VALUES (1024, 2049, 'Weibo');");
158 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
159 VALUES (1024, 2049, 'Camera');");
160 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
161 VALUES (1024, 2049, 'Screenshots');");
162 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) \
163 VALUES (1024, 2049, 'Screenrecorder');");
164 photosStorePtr->ExecuteSql("INSERT INTO PhotoAlbum (album_type, album_subtype,album_name) VALUES (1024, 2049,'" +
165 GetDUALBundleName() + " Share');");
166 }
167
Init(GallerySource & gallerySource,ExternalSource & externalSource)168 void Init(GallerySource &gallerySource, ExternalSource &externalSource)
169 {
170 MEDIA_INFO_LOG("start init galleryDb");
171 const string galleryDbPath = TEST_BACKUP_PATH + "/" + GALLERY_APP_NAME + "/ce/databases/gallery.db";
172 gallerySource.Init(galleryDbPath);
173 MEDIA_INFO_LOG("end init galleryDb");
174 MEDIA_INFO_LOG("start init externalDb");
175 const string externalDbPath = TEST_BACKUP_PATH + "/" + MEDIA_APP_NAME + "/ce/databases/external.db";
176 externalSource.Init(externalDbPath);
177 MEDIA_INFO_LOG("end init externalDb");
178 const string dbPath = TEST_BACKUP_PATH + "/" + MEDIA_LIBRARY_APP_NAME + "/ce/databases/media_library.db";
179 NativeRdb::RdbStoreConfig config(dbPath);
180 PhotosOpenCall helper;
181 int errCode = 0;
182 shared_ptr<NativeRdb::RdbStore> store = NativeRdb::RdbHelper::GetRdbStore(config, 1, helper, errCode);
183 photosStorePtr = store;
184 InitPhotoAlbum();
185 restoreService = std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, UPGRADE_RESTORE_ID);
186 restoreService->Init(TEST_BACKUP_PATH, TEST_UPGRADE_FILE_DIR, false);
187 restoreService->InitGarbageAlbum();
188 }
189
RestoreFromGallery()190 void RestoreFromGallery()
191 {
192 std::vector<FileInfo> fileInfos = restoreService->QueryFileInfos(0);
193 for (size_t i = 0; i < fileInfos.size(); i++) {
194 const NativeRdb::ValuesBucket values = restoreService->GetInsertValue(fileInfos[i], TEST_BACKUP_PATH,
195 SourceType::GALLERY);
196 int64_t rowNum = 0;
197 if (photosStorePtr->Insert(rowNum, "Photos", values) != E_OK) {
198 MEDIA_ERR_LOG("InsertSql failed, filePath = %{private}s", fileInfos[i].filePath.c_str());
199 }
200 }
201 }
202
RestoreFromExternal(GallerySource & gallerySource,bool isCamera)203 void RestoreFromExternal(GallerySource &gallerySource, bool isCamera)
204 {
205 MEDIA_INFO_LOG("start restore from %{public}s", (isCamera ? "camera" : "others"));
206 int32_t maxId = BackupDatabaseUtils::QueryInt(gallerySource.galleryStorePtr_, isCamera ?
207 QUERY_MAX_ID_CAMERA_SCREENSHOT : QUERY_MAX_ID_OTHERS, CUSTOM_MAX_ID);
208 int32_t type = isCamera ? SourceType::EXTERNAL_CAMERA : SourceType::EXTERNAL_OTHERS;
209 std::vector<FileInfo> fileInfos = restoreService->QueryFileInfosFromExternal(0, maxId, isCamera);
210 MEDIA_INFO_LOG("%{public}d asset will restor, maxid: %{public}d", (int)fileInfos.size(), maxId);
211 for (size_t i = 0; i < fileInfos.size(); i++) {
212 const NativeRdb::ValuesBucket values = restoreService->GetInsertValue(fileInfos[i], TEST_BACKUP_PATH,
213 type);
214 int64_t rowNum = 0;
215 if (photosStorePtr->Insert(rowNum, "Photos", values) != E_OK) {
216 MEDIA_ERR_LOG("InsertSql failed, filePath = %{private}s", fileInfos[i].filePath.c_str());
217 }
218 }
219 }
220
SetUpTestCase(void)221 void MediaLibraryBackupTest::SetUpTestCase(void)
222 {
223 MEDIA_INFO_LOG("SetUpTestCase");
224 GallerySource gallerySource;
225 ExternalSource externalSource;
226 Init(gallerySource, externalSource);
227 RestoreFromGallery();
228 RestoreFromExternal(gallerySource, true);
229 RestoreFromExternal(gallerySource, false);
230 }
231
TearDownTestCase(void)232 void MediaLibraryBackupTest::TearDownTestCase(void)
233 {
234 MEDIA_INFO_LOG("TearDownTestCase");
235 }
236
237 // SetUp:Execute before each test case
SetUp()238 void MediaLibraryBackupTest::SetUp() {}
239
TearDown(void)240 void MediaLibraryBackupTest::TearDown(void) {}
241
242 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_init, TestSize.Level0)
243 {
244 MEDIA_INFO_LOG("medialib_backup_test_init start");
245 std::unique_ptr<UpgradeRestore> restoreService = std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME,
246 UPGRADE_RESTORE_ID);
247 int32_t result = restoreService->Init(TEST_BACKUP_PATH, TEST_UPGRADE_FILE_DIR, false);
248 EXPECT_EQ(result, 0);
249 MEDIA_INFO_LOG("medialib_backup_test_init end");
250 }
251
252 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_not_sync_valid, TestSize.Level0)
253 {
254 MEDIA_INFO_LOG("medialib_backup_test_not_sync_valid start");
255 std::string queryNotSyncValid = "SELECT file_id from Photos where display_name ='not_sync_weixin.jpg'";
256 auto resultSet = photosStorePtr->QuerySql(queryNotSyncValid);
257 ASSERT_FALSE(resultSet == nullptr);
258 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
259 MEDIA_INFO_LOG("medialib_backup_test_not_sync_valid end");
260 }
261
262 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_not_sync_invalid, TestSize.Level0)
263 {
264 MEDIA_INFO_LOG("medialib_backup_test_not_sync_invalid start");
265 std::string queryNotSyncInvalid =
266 "SELECT file_id from Photos where display_name ='not_sync_invalid.jpg'";
267 auto resultSet = photosStorePtr->QuerySql(queryNotSyncInvalid);
268 ASSERT_FALSE(resultSet == nullptr);
269 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
270 MEDIA_INFO_LOG("medialib_backup_test_not_sync_invalid end");
271 }
272
273 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_not_sync_pending_camera, TestSize.Level0)
274 {
275 MEDIA_INFO_LOG("medialib_backup_test_not_sync_pending_camera start");
276 std::string queryNotSyncPendingCamera =
277 "SELECT file_id from Photos where display_name ='not_sync_pending_camera.jpg'";
278 auto resultSet = photosStorePtr->QuerySql(queryNotSyncPendingCamera);
279 ASSERT_FALSE(resultSet == nullptr);
280 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
281 MEDIA_INFO_LOG("medialib_backup_test_not_sync_pending_camera end");
282 }
283
284 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_not_sync_pending_others, TestSize.Level0)
285 {
286 MEDIA_INFO_LOG("medialib_backup_test_not_sync_pending_others start");
287 std::string queryNotSyncPendingOthers =
288 "SELECT file_id from Photos where display_name ='not_sync_pending_others.jpg'";
289 auto resultSet = photosStorePtr->QuerySql(queryNotSyncPendingOthers);
290 ASSERT_FALSE(resultSet == nullptr);
291 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
292 MEDIA_INFO_LOG("medialib_backup_test_not_sync_pending_others end");
293 }
294
295 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_not_restore_size_0, TestSize.Level0)
296 {
297 MEDIA_INFO_LOG("medialib_backup_test_not_restore_size_0 start");
298 std::string queryNotSyncPendingOthers =
299 "SELECT file_id from Photos where display_name ='zero_size.jpg'";
300 auto resultSet = photosStorePtr->QuerySql(queryNotSyncPendingOthers);
301 ASSERT_FALSE(resultSet == nullptr);
302 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
303 MEDIA_INFO_LOG("medialib_backup_test_not_restore_size_0 end");
304 }
305
306 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_create_asset_path_by_id, TestSize.Level0)
307 {
308 MEDIA_INFO_LOG("medialib_backup_test_create_asset_path_by_id start");
309 int32_t uniqueId = 2;
310 int32_t fileType = 1;
311 std::string extension = "jpg";
312 std::string cloudPath;
313 int64_t currentTime = MediaFileUtils::UTCTimeSeconds();
314 std::string dir = RESTORE_CLOUD_DIR + "/" + to_string(uniqueId) + "/IMG_" +
315 to_string(MediaFileUtils::UTCTimeSeconds()) + "_00" + to_string(uniqueId) + "." + extension;
316 int32_t errCode = BackupFileUtils::CreateAssetPathById(uniqueId, fileType, extension, cloudPath);
317 MEDIA_INFO_LOG("dir: %{public}s, cloudPath: %{public}s", dir.c_str(), cloudPath.c_str());
318 ASSERT_TRUE(dir == cloudPath);
319 MEDIA_INFO_LOG("medialib_backup_test_create_asset_path_by_id end");
320 }
321
322 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_update_clone, TestSize.Level0)
323 {
324 MEDIA_INFO_LOG("medialib_backup_test_update_clone start");
325 int32_t uniqueId = 2;
326 int32_t fileType = 1;
327 std::string extension = "jpg";
328 std::string cloudPath;
329 int64_t currentTime = MediaFileUtils::UTCTimeSeconds();
330 std::string dir = RESTORE_CLOUD_DIR + "/" + to_string(uniqueId) + "/IMG_" +
331 to_string(MediaFileUtils::UTCTimeSeconds()) + "_00" + to_string(uniqueId) + "." + extension;
332 int32_t errCode = BackupFileUtils::CreateAssetPathById(uniqueId, fileType, extension, cloudPath);
333 MEDIA_INFO_LOG("dir: %{public}s, cloudPath: %{public}s", dir.c_str(), cloudPath.c_str());
334 ASSERT_TRUE(dir == cloudPath);
335 MEDIA_INFO_LOG("medialib_backup_test_update_clone end");
336 }
337
338 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_a_media_not_sync_valid, TestSize.Level0)
339 {
340 MEDIA_INFO_LOG("medialib_backup_test_a_media_not_sync_valid start");
341 std::string queryNotSyncValid = "SELECT file_id from Photos where display_name ='a_media_not_sync.jpg'";
342 auto resultSet = photosStorePtr->QuerySql(queryNotSyncValid);
343 ASSERT_FALSE(resultSet == nullptr);
344 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
345 MEDIA_INFO_LOG("medialib_backup_test_a_media_not_sync_valid end");
346 }
347
348 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_a_media_zero_size, TestSize.Level0)
349 {
350 MEDIA_INFO_LOG("medialib_backup_test_a_media_zero_size start");
351 std::string queryNotSyncValid = "SELECT file_id from Photos where display_name ='a_media_zero_size.jpg'";
352 auto resultSet = photosStorePtr->QuerySql(queryNotSyncValid);
353 ASSERT_FALSE(resultSet == nullptr);
354 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
355 MEDIA_INFO_LOG("medialib_backup_test_a_media_zero_size end");
356 }
357
358 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_duplicate_data, TestSize.Level0)
359 {
360 MEDIA_INFO_LOG("medialib_backup_test_duplicate_data start");
361 restoreService->photosRestore_.galleryRdb_ = restoreService->galleryRdb_;
362 ASSERT_NE(restoreService->photosRestore_.galleryRdb_, nullptr);
363
364 restoreService->AnalyzeGalleryErrorSource();
365 size_t count = restoreService->photosRestore_.duplicateDataUsedCountMap_.size();
366 MEDIA_INFO_LOG("count: %{public}zu", count);
367 EXPECT_EQ(count, 0); // has duplicate data
368
369 string dataPath = "/storage/emulated/0/A/media/Rocket/test/duplicate_data.mp4";
370 bool isDuplicateData = restoreService->photosRestore_.IsDuplicateData(dataPath);
371 MEDIA_INFO_LOG("check %{public}s: %{public}d", dataPath.c_str(), static_cast<int32_t>(isDuplicateData));
372 EXPECT_EQ(isDuplicateData, false); // first time used, not duplicate
373 isDuplicateData = restoreService->photosRestore_.IsDuplicateData(dataPath);
374 MEDIA_INFO_LOG("double check %{public}s: %{public}d", dataPath.c_str(), static_cast<int32_t>(isDuplicateData));
375 EXPECT_EQ(isDuplicateData, false); // second time used, duplicate
376 dataPath = "/storage/emulated/0/fake/fake.jpg";
377 isDuplicateData = restoreService->photosRestore_.IsDuplicateData(dataPath);
378 MEDIA_INFO_LOG("check %{public}s: %{public}d", dataPath.c_str(), static_cast<int32_t>(isDuplicateData));
379 EXPECT_EQ(isDuplicateData, false); // not exist in map, not duplicate
380 MEDIA_INFO_LOG("medialib_backup_test_duplicate_data end");
381 }
382
383 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_modify_file, TestSize.Level0)
384 {
385 MEDIA_INFO_LOG("medialib_backup_test_modify_file start");
386 struct stat bufBefore;
387 const char *path = "/data/test/backup/1.txt";
388 stat(path, &bufBefore);
389 int64_t beforeModifiedTime = MediaFileUtils::Timespec2Millisecond(bufBefore.st_mtim);
390 int64_t currentTime = MediaFileUtils::UTCTimeSeconds();
391 struct utimbuf buf;
392 buf.actime = currentTime;
393 buf.modtime = currentTime;
394 utime(path, &buf);
395 struct stat bufAfter;
396 stat(path, &bufAfter);
397 int64_t afterModifiedTime = MediaFileUtils::Timespec2Millisecond(bufAfter.st_mtim);
398 ASSERT_TRUE(afterModifiedTime != beforeModifiedTime);
399 MEDIA_INFO_LOG("medialib_backup_test_modify_file end");
400 }
401
402 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_mediaType_audio, TestSize.Level0)
403 {
404 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_mediaType_audio start");
405 int32_t uniqueId = 2;
406 int32_t fileType = 3;
407 std::string extension = "mp3";
408 std::string cloudPath;
409 int32_t errCode = BackupFileUtils::CreateAssetPathById(uniqueId, fileType, extension, cloudPath);
410 EXPECT_EQ(errCode, E_OK);
411 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_mediaType_audio end");
412 }
413
414 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_mediaType_video, TestSize.Level0)
415 {
416 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_mediaType_video start");
417 int32_t uniqueId = 2;
418 int32_t fileType = 2;
419 std::string extension = "mp4";
420 std::string cloudPath;
421 int32_t errCode = BackupFileUtils::CreateAssetPathById(uniqueId, fileType, extension, cloudPath);
422 EXPECT_EQ(errCode, E_OK);
423 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_mediaType_video end");
424 }
425
426 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_illegal_fileId, TestSize.Level0)
427 {
428 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Illegal_fileId start");
429 int32_t fileId = -1;
430 int32_t fileType = 2;
431 std::string extension = "mp4";
432 std::string cloudPath;
433 // fileId < 0 CreateAssetPathById will return E_INVALID_FILEID -208
434 int32_t errCode = BackupFileUtils::CreateAssetPathById(fileId, fileType, extension, cloudPath);
435 EXPECT_EQ(errCode, E_INVALID_FILEID);
436 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Illegal_fileId end");
437 }
438
439 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_Normal_fileId, TestSize.Level0)
440 {
441 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Normal_fileId start");
442 // file id > ASSET_DIR_START_NUM * ASSET_IN_BUCKET_NUM_MAX (16 * 1000) and Remainder != 0
443 int32_t fileId = 16 * 1000 + 1;
444 int32_t fileType = 2;
445 std::string extension = "mp4";
446 std::string cloudPath;
447 int32_t errCode = BackupFileUtils::CreateAssetPathById(fileId, fileType, extension, cloudPath);
448 EXPECT_EQ(errCode, E_OK);
449 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Normal_fileId end");
450 }
451
452 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_Normal_fileId_NoRemainder, TestSize.Level0)
453 {
454 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Normal_fileId_NoRemainder start");
455 // file id > ASSET_DIR_START_NUM * ASSET_IN_BUCKET_NUM_MAX (16 * 1000) and fileIdRemainder == 0
456 int32_t fileId = 16 * 1000 + 16;
457 int32_t fileType = 2;
458 std::string extension = "mp4";
459 std::string cloudPath;
460 int32_t errCode = BackupFileUtils::CreateAssetPathById(fileId, fileType, extension, cloudPath);
461 EXPECT_EQ(errCode, E_OK);
462 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Normal_fileId_NoRemainder end");
463 }
464
465 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_illegal_fileType_001, TestSize.Level0)
466 {
467 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_illegal_fileType_001 start");
468 int32_t fileId = 2;
469 int32_t fileType = -1;
470 std::string extension = "mp4";
471 std::string cloudPath;
472 // normal fileId and illegal fileType CreateAssetPathById will return E_INVALID_VALUES
473 int32_t errCode = BackupFileUtils::CreateAssetPathById(fileId, fileType, extension, cloudPath);
474 EXPECT_EQ(errCode, E_INVALID_VALUES);
475 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_illegal_fileType_001 end");
476 }
477
478 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_Illegal_fileType_002, TestSize.Level0)
479 {
480 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Illegal_fileType_002 start");
481 // fileId = ASSET_MAX_COMPLEMENT_ID + invalid file type
482 int32_t fileId = 999;
483 int32_t fileType = -1;
484 std::string extension = "mp4";
485 std::string cloudPath;
486 int32_t errCode = BackupFileUtils::CreateAssetPathById(fileId, fileType, extension, cloudPath);
487 EXPECT_EQ(errCode, E_INVALID_VALUES);
488 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Illegal_fileType_002 end");
489 }
490
491 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_CreateAssetPathById_Illegal_fileType_003, TestSize.Level0)
492 {
493 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Illegal_fileType_003 start");
494 // fileId > ASSET_MAX_COMPLEMENT_ID + invalid file type
495 int32_t fileId = 1000;
496 int32_t fileType = -1;
497 std::string extension = "mp4";
498 std::string cloudPath;
499 int32_t errCode = BackupFileUtils::CreateAssetPathById(fileId, fileType, extension, cloudPath);
500 EXPECT_EQ(errCode, E_INVALID_VALUES);
501 MEDIA_INFO_LOG("BackupFileUtils_CreateAssetPathById_Illegal_fileType_003 end");
502 }
503
504 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFileNameFromPath_path_empty, TestSize.Level0)
505 {
506 MEDIA_INFO_LOG("BackupFileUtils_GetFileNameFromPath_path_empty start");
507 string path;
508 string res = BackupFileUtils::GetFileNameFromPath(path);
509 EXPECT_EQ(res, "");
510 MEDIA_INFO_LOG("BackupFileUtils_GetFileNameFromPath_path_empty end");
511 }
512
513 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFileNameFromPath_path_not_have, TestSize.Level0)
514 {
515 MEDIA_INFO_LOG("BackupFileUtils_GetFileNameFromPath_path_not_have start");
516 string path = "test";
517 string res = BackupFileUtils::GetFileNameFromPath(path);
518 EXPECT_EQ(res, "");
519 MEDIA_INFO_LOG("BackupFileUtils_GetFileNameFromPath_path_not_have end");
520 }
521
522 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFileNameFromPath_ok, TestSize.Level0)
523 {
524 MEDIA_INFO_LOG("BackupFileUtils_GetFileNameFromPath_ok start");
525 string path = "test/ee/ee";
526 string res = BackupFileUtils::GetFileNameFromPath(path);
527 EXPECT_NE(res, "");
528 MEDIA_INFO_LOG("BackupFileUtils_GetFileNameFromPath_ok end");
529 }
530
531 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFileTitle_dispalyName_empty, TestSize.Level0)
532 {
533 MEDIA_INFO_LOG("BackupFileUtils_GetFileTitle_dispalyName_empty start");
534 string displayName;
535 string res = BackupFileUtils::GetFileTitle(displayName);
536 EXPECT_EQ(res, "");
537 MEDIA_INFO_LOG("BackupFileUtils_GetFileTitle_dispalyName_empty end");
538 }
539
540 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFileTitle_ok, TestSize.Level0)
541 {
542 MEDIA_INFO_LOG("BackupFileUtils_GetFileTitle_ok start");
543 string displayName = "test.mp3";
544 string res = BackupFileUtils::GetFileTitle(displayName);
545 EXPECT_NE(res, "");
546 MEDIA_INFO_LOG("BackupFileUtils_GetFileTitle_ok end");
547 }
548
549 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFileTitle_no_dot, TestSize.Level0)
550 {
551 MEDIA_INFO_LOG("BackupFileUtils_GetFileTitle_no_dot start");
552 string displayName = "testmp3";
553 string res = BackupFileUtils::GetFileTitle(displayName);
554 EXPECT_EQ(res, "testmp3");
555 MEDIA_INFO_LOG("BackupFileUtils_GetFileTitle_no_dot end");
556 }
557
558 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFullPathByPrefixType_normal_type, TestSize.Level0)
559 {
560 MEDIA_INFO_LOG("BackupFileUtils_GetFullPathByPrefixType_normal_type start");
561 // test case 1 normal PrefixType
562 string path = "/test.cpp";
563 PrefixType type = PrefixType::CLOUD;
564 string res = BackupFileUtils::GetFullPathByPrefixType(type, path);
565 EXPECT_EQ(res, "/storage/cloud/files/test.cpp");
566 MEDIA_INFO_LOG("BackupFileUtils_GetFullPathByPrefixType_normal_type end");
567 }
568
569 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetFullPathByPrefixType_illegal_type, TestSize.Level0)
570 {
571 MEDIA_INFO_LOG("BackupFileUtils_GetFullPathByPrefixType_illegal_type start");
572 // test case 2 illegal PrefixType
573 string path = "/test.cpp";
574 PrefixType type = static_cast<PrefixType>(-1);
575 string res = BackupFileUtils::GetFullPathByPrefixType(type, path);
576 EXPECT_EQ(res.length(), 0);
577 MEDIA_INFO_LOG("BackupFileUtils_GetFullPathByPrefixType_illegal_type end");
578 }
579
580 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GarbleFileName_normal_name, TestSize.Level0)
581 {
582 MEDIA_INFO_LOG("BackupFileUtils_GarbleFileName_normal_name start");
583 // name start with Screenshot_
584 string name = "Screenshot_test";
585 auto ret = BackupFileUtils::GarbleFileName(name);
586 EXPECT_EQ(ret, "Screenshot_test");
587
588 // name start with SVID_
589 name = "SVID_test";
590 ret = BackupFileUtils::GarbleFileName(name);
591 EXPECT_EQ(ret, "SVID_test");
592
593 // name start with IMG_
594 name = "IMG_test";
595 ret = BackupFileUtils::GarbleFileName(name);
596 EXPECT_EQ(ret, "IMG_test");
597
598 // name start with VID_
599 name = "VID_test";
600 ret = BackupFileUtils::GarbleFileName(name);
601 EXPECT_EQ(ret, "VID_test");
602
603 // name without extension and size <= GARBLE.size() * 2
604 name = "test";
605 ret = BackupFileUtils::GarbleFileName(name);
606 EXPECT_EQ(ret, name);
607
608 // name with extension
609 name = "test_garble_file_name.ext";
610 ret = BackupFileUtils::GarbleFileName(name);
611 EXPECT_EQ(ret.find(GARBLE), 0);
612 MEDIA_INFO_LOG("BackupFileUtils_GarbleFileName_normal_name end");
613 }
614
615 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GarbleFileName_empty_name, TestSize.Level0)
616 {
617 MEDIA_INFO_LOG("BackupFileUtils_GarbleFileName_empty_name start");
618 // empty file name
619 string name;
620 auto ret = BackupFileUtils::GarbleFileName(name);
621 EXPECT_EQ(ret.length(), 0);
622 MEDIA_INFO_LOG("BackupFileUtils_GarbleFileName_empty_name end");
623 }
624
625 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetReplacedPathByPrefixType_illegal_srcprefix, TestSize.Level0)
626 {
627 MEDIA_INFO_LOG("BackupFileUtils_GetReplacedPathByPrefixType_illegal_srcprefix start");
628 // illegal srcPrefix + normal dstPrefix
629 PrefixType srcPrefix = static_cast<PrefixType>(-1);
630 PrefixType dstPrefix = PrefixType::CLOUD_EDIT_DATA;
631 string path = "test_path";
632 auto ret = BackupFileUtils::GetReplacedPathByPrefixType(srcPrefix, dstPrefix, path);
633 EXPECT_EQ(ret.length(), 0);
634 MEDIA_INFO_LOG("BackupFileUtils_GetReplacedPathByPrefixType_illegal_srcprefix end");
635 }
636
637 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetReplacedPathByPrefixType_illegal_dstprefix, TestSize.Level0)
638 {
639 MEDIA_INFO_LOG("BackupFileUtils_GetReplacedPathByPrefixType_illegal_dstprefix start");
640 // illegal dstPrefix + normal srcPrefix
641 PrefixType srcPrefix = PrefixType::CLOUD_EDIT_DATA;
642 PrefixType dstPrefix = static_cast<PrefixType>(-1);
643 string path = "test_path";
644 auto ret = BackupFileUtils::GetReplacedPathByPrefixType(srcPrefix, dstPrefix, path);
645 EXPECT_EQ(ret.length(), 0);
646 MEDIA_INFO_LOG("BackupFileUtils_GetReplacedPathByPrefixType_illegal_dstprefix end");
647 }
648
649 HWTEST_F(MediaLibraryBackupTest, BackupFileUtils_GetReplacedPathByPrefixType_normal_prefix, TestSize.Level0)
650 {
651 MEDIA_INFO_LOG("BackupFileUtils_GetReplacedPathByPrefixType_normal_prefix start");
652 // normal srcPrefix + normal dstPrefix
653 PrefixType srcPrefix = PrefixType::LOCAL;
654 PrefixType dstPrefix = PrefixType::LOCAL;
655 string path = "test_path";
656 auto ret = BackupFileUtils::GetReplacedPathByPrefixType(srcPrefix, dstPrefix, path);
657 EXPECT_EQ(ret, "/storage/media/local/files");
658 MEDIA_INFO_LOG("BackupFileUtils_GetReplacedPathByPrefixType_normal_prefix end");
659 }
660
661 HWTEST_F(MediaLibraryBackupTest, RestoreAudio_sceneCode_UPGRADE_RESTORE_ID, TestSize.Level0)
662 {
663 MEDIA_INFO_LOG("RestoreAudio_sceneCode_UPGRADE_RESTORE_ID start");
664 restoreService->RestoreAudio();
665 std::string queryAudio = "SELECT file_id from Audios where display_name ='audio1.mp3'";
666 auto resultSet = photosStorePtr->QuerySql(queryAudio);
667 ASSERT_FALSE(resultSet == nullptr);
668 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
669 MEDIA_INFO_LOG("RestoreAudio_sceneCode_UPGRADE_RESTORE_ID end");
670 }
671
672 HWTEST_F(MediaLibraryBackupTest, RestoreAudio_sceneCode_Clone, TestSize.Level0)
673 {
674 MEDIA_INFO_LOG("RestoreAudio_sceneCode_Clone start");
675 restoreService->sceneCode_ = DUAL_FRAME_CLONE_RESTORE_ID;
676 restoreService->RestoreAudio();
677 std::string queryAudio = "SELECT file_id from Audios where display_name ='audio1.mp3'";
678 auto resultSet = photosStorePtr->QuerySql(queryAudio);
679 ASSERT_FALSE(resultSet == nullptr);
680 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
681 MEDIA_INFO_LOG("RestoreAudio_sceneCode_Clone end");
682 }
683
684 HWTEST_F(MediaLibraryBackupTest, RestoreAudio_RestoreAudioBatch_clone_no_audioRdb, TestSize.Level0)
685 {
686 MEDIA_INFO_LOG("RestoreAudio_RestoreAudioBatch_clone_no_db start");
687 std::unique_ptr<UpgradeRestore> upgrade =
688 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
689 upgrade->RestoreAudioBatch(0);
690 std::string queryAudio = "SELECT file_id from Audios where display_name ='audio1.mp3'";
691 auto resultSet = photosStorePtr->QuerySql(queryAudio);
692 ASSERT_FALSE(resultSet == nullptr);
693 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
694 MEDIA_INFO_LOG("RestoreAudio_RestoreAudioBatch_clone_no_db end");
695 }
696
697 HWTEST_F(MediaLibraryBackupTest, RestoreAudio_RestoreAudioBatch_clone_fake_audiodb, TestSize.Level0)
698 {
699 MEDIA_INFO_LOG("RestoreAudio_RestoreAudioBatch_clone_fake_audiodb start");
700 std::unique_ptr<UpgradeRestore> upgrade =
701 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
702 upgrade->audioRdb_ = photosStorePtr;
703 upgrade->RestoreAudioBatch(0);
704 std::string queryAudio = "SELECT file_id from Audios where display_name ='audio1.mp3'";
705 auto resultSet = photosStorePtr->QuerySql(queryAudio);
706 ASSERT_FALSE(resultSet == nullptr);
707 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
708 MEDIA_INFO_LOG("RestoreAudio_RestoreAudioBatch_clone_no_db end");
709 }
710
711 HWTEST_F(MediaLibraryBackupTest, RestoreAudio_ParseResultSetFromAudioDb_return_false, TestSize.Level0)
712 {
713 MEDIA_INFO_LOG("RestoreAudio_ParseResultSetFromAudioDb_return_false start");
714 std::unique_ptr<UpgradeRestore> upgrade =
715 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
716 std::shared_ptr<NativeRdb::ResultSet> resultSet;
717 FileInfo info;
718 bool res = upgrade->ParseResultSetFromAudioDb(resultSet, info);
719 EXPECT_NE(res, true);
720 MEDIA_INFO_LOG("RestoreAudio_ParseResultSetFromAudioDb_return_false end");
721 }
722
723 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test001, TestSize.Level0)
724 {
725 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test001 start";
726 MEDIA_INFO_LOG("medialib_backup_test_ablum_test001 start");
727 restoreService->RestorePhoto();
728 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'test001';";
729 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
730 ASSERT_FALSE(resultSet == nullptr);
731 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
732 MEDIA_INFO_LOG("medialib_backup_test_ablum_test001 end");
733 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test001 end";
734 }
735
736 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test002, TestSize.Level0)
737 {
738 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test002 start";
739 MEDIA_INFO_LOG("medialib_backup_test_ablum_test002 start");
740 restoreService->RestorePhoto();
741 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'test002';";
742 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
743 ASSERT_FALSE(resultSet == nullptr);
744 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
745 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test002 end";
746 }
747
748 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test003, TestSize.Level0)
749 {
750 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test003 start";
751 MEDIA_INFO_LOG("medialib_backup_test_ablum_test003 start");
752 restoreService->RestorePhoto();
753 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'test003';";
754 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
755 ASSERT_FALSE(resultSet == nullptr);
756 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
757 MEDIA_INFO_LOG("medialib_backup_test_ablum_test003 end");
758 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test003 end";
759 }
760
761 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test004, TestSize.Level0)
762 {
763 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test004 start";
764 MEDIA_INFO_LOG("medialib_backup_test_ablum_test004 start");
765 restoreService->RestorePhoto();
766 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'TmallPic';";
767 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
768 ASSERT_FALSE(resultSet == nullptr);
769 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
770 MEDIA_INFO_LOG("medialib_backup_test_ablum_test004 end");
771 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test004 end";
772 }
773
774 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test005, TestSize.Level0)
775 {
776 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test005 start";
777 MEDIA_INFO_LOG("medialib_backup_test_ablum_test005 start");
778 restoreService->RestorePhoto();
779 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'UCDownloads';";
780 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
781 ASSERT_FALSE(resultSet == nullptr);
782 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
783 MEDIA_INFO_LOG("medialib_backup_test_ablum_test005 end");
784 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test005 end";
785 }
786
787 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test006, TestSize.Level0)
788 {
789 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test006 start";
790 MEDIA_INFO_LOG("medialib_backup_test_ablum_test006 start");
791 restoreService->RestorePhoto();
792 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'xiaohongshu';";
793 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
794 ASSERT_FALSE(resultSet == nullptr);
795 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
796 MEDIA_INFO_LOG("medialib_backup_test_ablum_test006 end");
797 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test006 end";
798 }
799
800 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test007, TestSize.Level0)
801 {
802 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test007 start";
803 MEDIA_INFO_LOG("medialib_backup_test_ablum_test007 start");
804 restoreService->RestorePhoto();
805 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Douyin';";
806 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
807 ASSERT_FALSE(resultSet == nullptr);
808 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
809 MEDIA_INFO_LOG("medialib_backup_test_ablum_test007 end");
810 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test007 end";
811 }
812
813 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test008, TestSize.Level0)
814 {
815 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test008 start";
816 MEDIA_INFO_LOG("medialib_backup_test_ablum_test008 start");
817 restoreService->RestorePhoto();
818 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Weibo';";
819 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
820 ASSERT_FALSE(resultSet == nullptr);
821 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
822 MEDIA_INFO_LOG("medialib_backup_test_ablum_test008 end");
823 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test008 end";
824 }
825
826 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test009, TestSize.Level0)
827 {
828 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test009 start";
829 MEDIA_INFO_LOG("medialib_backup_test_ablum_test009 start");
830 restoreService->RestorePhoto();
831 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Camera';";
832 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
833 ASSERT_FALSE(resultSet == nullptr);
834 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
835
836 queryTrashed = "SELECT file_id from Photos where display_name = 'camera1.jpg';";
837 resultSet = photosStorePtr->QuerySql(queryTrashed);
838 ASSERT_FALSE(resultSet == nullptr);
839 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
840 MEDIA_INFO_LOG("medialib_backup_test_ablum_test009 end");
841 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test009 end";
842 }
843
844 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test010, TestSize.Level0)
845 {
846 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test010 start";
847 MEDIA_INFO_LOG("medialib_backup_test_ablum_test010 start");
848 restoreService->RestorePhoto();
849 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Screenshots';";
850 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
851 ASSERT_FALSE(resultSet == nullptr);
852 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
853
854 queryTrashed = "SELECT file_id from Photos where display_name = 'screenshots1.jpg';";
855 resultSet = photosStorePtr->QuerySql(queryTrashed);
856 ASSERT_FALSE(resultSet == nullptr);
857 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
858 MEDIA_INFO_LOG("medialib_backup_test_ablum_test010 end");
859 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test010 end";
860 }
861
862 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test011, TestSize.Level0)
863 {
864 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test011 start";
865 MEDIA_INFO_LOG("medialib_backup_test_ablum_test011 start");
866 restoreService->RestorePhoto();
867 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Screenrecorder';";
868 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
869 ASSERT_FALSE(resultSet == nullptr);
870 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
871
872 queryTrashed = "SELECT file_id from Photos where display_name = 'screenrecorder1.mp4';";
873 resultSet = photosStorePtr->QuerySql(queryTrashed);
874 ASSERT_FALSE(resultSet == nullptr);
875 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
876 MEDIA_INFO_LOG("medialib_backup_test_ablum_test011 end");
877 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test011 end";
878 }
879
880 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test012, TestSize.Level0)
881 {
882 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test012 start";
883 MEDIA_INFO_LOG("medialib_backup_test_ablum_test012 start");
884 restoreService->RestorePhoto();
885 std::string sql = "SELECT album_id from PhotoAlbum where album_name = '" + GetDUALBundleName() + " Share';";
886 auto resultSet = photosStorePtr->QuerySql(sql);
887 ASSERT_FALSE(resultSet == nullptr);
888 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
889
890 sql = "SELECT file_id from Photos where display_name = '" + GetDUALBundleName() + "Share1.jpg';";
891 resultSet = photosStorePtr->QuerySql(sql);
892 ASSERT_FALSE(resultSet == nullptr);
893 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
894 MEDIA_INFO_LOG("medialib_backup_test_ablum_test012 end");
895 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test012 end";
896 }
897
898 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test101, TestSize.Level0)
899 {
900 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test101 start";
901 MEDIA_INFO_LOG("medialib_backup_test_ablum_test101 start");
902 restoreService->RestorePhoto();
903 std::string queryTrashed = "SELECT album_type,album_subtype from PhotoAlbum where album_name = 'test101';";
904 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
905 int32_t album_type = GetInt32Val("album_type", resultSet);
906 int32_t album_subtype = GetInt32Val("album_subtype", resultSet);
907 ASSERT_FALSE(resultSet == nullptr);
908 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
909
910 EXPECT_EQ(album_type, 0);
911 EXPECT_EQ(album_subtype, 0);
912 MEDIA_INFO_LOG("medialib_backup_test_ablum_test101 end");
913 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test101 end";
914 }
915
916 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test102, TestSize.Level0)
917 {
918 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test102 start";
919 MEDIA_INFO_LOG("medialib_backup_test_ablum_test102 start");
920 restoreService->RestorePhoto();
921 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'TmallPic';";
922 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
923 ASSERT_FALSE(resultSet == nullptr);
924 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
925 MEDIA_INFO_LOG("medialib_backup_test_ablum_test102 end");
926 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test102 end";
927 }
928
929 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test103, TestSize.Level0)
930 {
931 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test103 start";
932 MEDIA_INFO_LOG("medialib_backup_test_ablum_test103 start");
933 restoreService->RestorePhoto();
934 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'MTTT';";
935 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
936 ASSERT_FALSE(resultSet == nullptr);
937 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
938 MEDIA_INFO_LOG("medialib_backup_test_ablum_test103 end");
939 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test103 end";
940 }
941
942 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test104, TestSize.Level0)
943 {
944 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test104 start";
945 MEDIA_INFO_LOG("medialib_backup_test_ablum_test104 start");
946 restoreService->RestorePhoto();
947 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'funnygallery';";
948 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
949 ASSERT_FALSE(resultSet == nullptr);
950 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
951 MEDIA_INFO_LOG("medialib_backup_test_ablum_test104 end");
952 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test104 end";
953 }
954
955 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test105, TestSize.Level0)
956 {
957 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test105 start";
958 MEDIA_INFO_LOG("medialib_backup_test_ablum_test105 start");
959 restoreService->RestorePhoto();
960 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'xiaohongshu';";
961 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
962 ASSERT_FALSE(resultSet == nullptr);
963 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
964 MEDIA_INFO_LOG("medialib_backup_test_ablum_test105 end");
965 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test105 end";
966 }
967
968 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test106, TestSize.Level0)
969 {
970 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test106 start";
971 MEDIA_INFO_LOG("medialib_backup_test_ablum_test106 start");
972 restoreService->RestorePhoto();
973 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Douyin';";
974 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
975 ASSERT_FALSE(resultSet == nullptr);
976 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
977 MEDIA_INFO_LOG("medialib_backup_test_ablum_test106 end");
978 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test106 end";
979 }
980
981 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test107, TestSize.Level0)
982 {
983 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test107 start";
984 MEDIA_INFO_LOG("medialib_backup_test_ablum_test107 start");
985 restoreService->RestorePhoto();
986 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'save';";
987 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
988 ASSERT_FALSE(resultSet == nullptr);
989 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
990 MEDIA_INFO_LOG("medialib_backup_test_ablum_test107 end");
991 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test107 end";
992 }
993
994 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test108, TestSize.Level0)
995 {
996 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test108 start";
997 MEDIA_INFO_LOG("medialib_backup_test_ablum_test108 start");
998 restoreService->RestorePhoto();
999 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Weibo';";
1000 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
1001 ASSERT_FALSE(resultSet == nullptr);
1002 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1003 MEDIA_INFO_LOG("medialib_backup_test_ablum_test108 end");
1004 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test108 end";
1005 }
1006
1007 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test109, TestSize.Level0)
1008 {
1009 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test109 start";
1010 MEDIA_INFO_LOG("medialib_backup_test_ablum_test109 start");
1011 restoreService->RestorePhoto();
1012 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Camera';";
1013 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
1014 ASSERT_FALSE(resultSet == nullptr);
1015 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1016
1017 queryTrashed = "SELECT file_id from Photos where display_name = 'camera2.jpg';";
1018 resultSet = photosStorePtr->QuerySql(queryTrashed);
1019 ASSERT_FALSE(resultSet == nullptr);
1020 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1021 MEDIA_INFO_LOG("medialib_backup_test_ablum_test109 end");
1022 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test109 end";
1023 }
1024
1025 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test110, TestSize.Level0)
1026 {
1027 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test110 start";
1028 MEDIA_INFO_LOG("medialib_backup_test_ablum_test110 start");
1029 restoreService->RestorePhoto();
1030 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Screenshots';";
1031 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
1032 ASSERT_FALSE(resultSet == nullptr);
1033 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1034
1035 queryTrashed = "SELECT file_id from Photos where display_name = 'screenshots2.jpg';";
1036 resultSet = photosStorePtr->QuerySql(queryTrashed);
1037 ASSERT_FALSE(resultSet == nullptr);
1038 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1039 MEDIA_INFO_LOG("medialib_backup_test_ablum_test110 end");
1040 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test110 end";
1041 }
1042
1043 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test111, TestSize.Level0)
1044 {
1045 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test111 start";
1046 MEDIA_INFO_LOG("medialib_backup_test_ablum_test111 start");
1047 restoreService->RestorePhoto();
1048 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = 'Screenrecorder';";
1049 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
1050 ASSERT_FALSE(resultSet == nullptr);
1051 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1052
1053 queryTrashed = "SELECT file_id from Photos where display_name = 'screenrecorder2.mp4';";
1054 resultSet = photosStorePtr->QuerySql(queryTrashed);
1055 ASSERT_FALSE(resultSet == nullptr);
1056 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1057 MEDIA_INFO_LOG("medialib_backup_test_ablum_test111 end");
1058 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test111 end";
1059 }
1060
1061 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ablum_test112, TestSize.Level0)
1062 {
1063 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test112 start";
1064 MEDIA_INFO_LOG("medialib_backup_test_ablum_test112 start");
1065 restoreService->RestorePhoto();
1066 std::string queryTrashed = "SELECT album_id from PhotoAlbum where album_name = '" + GetDUALBundleName() +" Share';";
1067 auto resultSet = photosStorePtr->QuerySql(queryTrashed);
1068 ASSERT_FALSE(resultSet == nullptr);
1069 ASSERT_TRUE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1070
1071 queryTrashed = "SELECT file_id from Photos where display_name = '" + GetDUALBundleName() + "Share2.jpg';";
1072 resultSet = photosStorePtr->QuerySql(queryTrashed);
1073 ASSERT_FALSE(resultSet == nullptr);
1074 ASSERT_FALSE(resultSet->GoToNextRow() == NativeRdb::E_OK);
1075 MEDIA_INFO_LOG("medialib_backup_test_ablum_test112 end");
1076 GTEST_LOG_(INFO) << "medialib_backup_test_ablum_test112 end";
1077 }
1078
1079 HWTEST_F(MediaLibraryBackupTest, medialib_backup_InsertAudio_upgrade, TestSize.Level0)
1080 {
1081 MEDIA_INFO_LOG("medialib_backup_InsertAudio_upgrade start");
1082 std::unique_ptr<UpgradeRestore> upgrade =
1083 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1084 upgrade->mediaLibraryRdb_ = photosStorePtr;
1085 upgrade->migrateAudioDatabaseNumber_ = 0;
1086 std::vector<FileInfo> fileInfos;
1087 FileInfo fileInfo1;
1088 fileInfo1.filePath = "test";
1089 fileInfos.push_back(fileInfo1);
1090 FileInfo fileInfo2;
1091 fileInfo2.filePath = "/storage/cloud/100/files/Documents/CreateImageThumbnailTest_001.jpg";
1092 fileInfo2.cloudPath = "/storage/cloud/files/Audio/10/AUD_3322.jpg";
1093 fileInfos.push_back(fileInfo2);
1094 upgrade->InsertAudio(UPGRADE_RESTORE_ID, fileInfos);
1095 EXPECT_EQ(upgrade->migrateAudioDatabaseNumber_, 0);
1096 MEDIA_INFO_LOG("medialib_backup_InsertAudio_upgrade end");
1097 }
1098
1099 HWTEST_F(MediaLibraryBackupTest, medialib_backup_InsertAudio_clone, TestSize.Level0)
1100 {
1101 MEDIA_INFO_LOG("medialib_backup_InsertAudio_clone start");
1102 std::unique_ptr<UpgradeRestore> upgrade =
1103 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1104 upgrade->mediaLibraryRdb_ = photosStorePtr;
1105 upgrade->migrateAudioDatabaseNumber_ = 0;
1106 std::vector<FileInfo> fileInfos;
1107 FileInfo fileInfo1;
1108 fileInfo1.filePath = "test";
1109 fileInfos.push_back(fileInfo1);
1110 FileInfo fileInfo2;
1111 fileInfo2.filePath = "/storage/cloud/100/files/Documents/CreateImageThumbnailTest_001.jpg";
1112 fileInfo2.cloudPath = "/storage/cloud/files/Audio/10/AUD_3322.jpg";
1113 fileInfos.push_back(fileInfo2);
1114 upgrade->InsertAudio(DUAL_FRAME_CLONE_RESTORE_ID, fileInfos);
1115 EXPECT_EQ(upgrade->migrateAudioDatabaseNumber_, 0);
1116 MEDIA_INFO_LOG("medialib_backup_InsertAudio_clone end");
1117 }
1118
1119 HWTEST_F(MediaLibraryBackupTest, medialib_backup_InsertAudio_empty_file, TestSize.Level0)
1120 {
1121 MEDIA_INFO_LOG("medialib_backup_InsertAudio_empty_file start");
1122 std::unique_ptr<UpgradeRestore> upgrade =
1123 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1124 upgrade->mediaLibraryRdb_ = photosStorePtr;
1125 upgrade->migrateAudioDatabaseNumber_ = 0;
1126 std::vector<FileInfo> fileInfos;
1127 upgrade->InsertAudio(DUAL_FRAME_CLONE_RESTORE_ID, fileInfos);
1128 EXPECT_EQ(upgrade->migrateAudioDatabaseNumber_, 0);
1129 MEDIA_INFO_LOG("medialib_backup_InsertAudio_empty_file end");
1130 }
1131
1132 HWTEST_F(MediaLibraryBackupTest, medialib_backup_MoveDirectory, TestSize.Level0)
1133 {
1134 MEDIA_INFO_LOG("medialib_backup_MoveDirectory start");
1135 std::unique_ptr<UpgradeRestore> upgrade =
1136 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1137 string srcDir = "/data/test";
1138 string dstDir = "/data/test1";
1139 EXPECT_EQ(upgrade->MoveDirectory(srcDir, dstDir), E_OK);
1140 // delete the destination directory after moving to prevent errors caused by an existing directory
1141 auto ret = MediaFileUtils::DeleteDir(dstDir);
1142 EXPECT_EQ(ret, true);
1143 MEDIA_INFO_LOG("medialib_backup_MoveDirectory end");
1144 }
1145
1146 HWTEST_F(MediaLibraryBackupTest, medialib_backup_BatchQueryPhoto, TestSize.Level0)
1147 {
1148 MEDIA_INFO_LOG("medialib_backup_BatchQueryPhoto start");
1149 vector<FileInfo> fileInfos;
1150 FileInfo fileInfo1;
1151 fileInfo1.cloudPath = "test";
1152 fileInfo1.mediaAlbumId = TEST_FALSE_MEDIAID;
1153 fileInfos.push_back(fileInfo1);
1154
1155 FileInfo fileInfo2;
1156 fileInfo2.cloudPath = "";
1157 fileInfo2.mediaAlbumId = TEST_FALSE_MEDIAID;
1158 fileInfos.push_back(fileInfo2);
1159
1160 FileInfo fileInfo3;
1161 fileInfo3.cloudPath = "test";
1162 fileInfo3.mediaAlbumId = TEST_TRUE_MEDIAID;
1163 fileInfos.push_back(fileInfo3);
1164
1165 FileInfo fileInfo4;
1166 fileInfo4.cloudPath = "";
1167 fileInfo4.mediaAlbumId = TEST_TRUE_MEDIAID;
1168 fileInfos.push_back(fileInfo4);
1169 std::unique_ptr<UpgradeRestore> upgrade =
1170 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1171 NeedQueryMap needQueryMap;
1172 upgrade->NeedBatchQueryPhotoForPhotoMap(fileInfos, needQueryMap);
1173 upgrade->BatchQueryPhoto(fileInfos, false, needQueryMap);
1174 EXPECT_EQ(fileInfos[0].fileIdNew, TEST_FALSE_MEDIAID);
1175 MEDIA_INFO_LOG("medialib_backup_BatchQueryPhoto end");
1176 }
1177
1178 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ParseXml_002, TestSize.Level0)
1179 {
1180 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_002 start";
1181 std::unique_ptr<UpgradeRestore> upgrade =
1182 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1183 string xmlPath = "/data/test/backup/test1.xml";
1184 auto res = upgrade->ParseXml(xmlPath);
1185 EXPECT_EQ(res, -1);
1186 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_002 end";
1187 }
1188
1189 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ParseXml_003, TestSize.Level0)
1190 {
1191 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_003 start";
1192 std::unique_ptr<UpgradeRestore> upgrade =
1193 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1194 string xmlPath = "/data/test/backup/test2.xml";
1195 auto res = upgrade->ParseXml(xmlPath);
1196 EXPECT_EQ(res, -1);
1197 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_003 end";
1198 }
1199
1200 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ParseXml_004, TestSize.Level0)
1201 {
1202 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_004 start";
1203 std::unique_ptr<UpgradeRestore> upgrade =
1204 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1205 string xmlPath = "/data/test/backup/test3.xml";
1206 auto res = upgrade->ParseXml(xmlPath);
1207 EXPECT_EQ(res, -1);
1208 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_004 end";
1209 }
1210
1211 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_ParseXml_005, TestSize.Level0)
1212 {
1213 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_005 start";
1214 std::unique_ptr<UpgradeRestore> upgrade =
1215 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1216 string xmlPath = "/data/test/backup/test4.xml";
1217 auto res = upgrade->ParseXml(xmlPath);
1218 EXPECT_EQ(res, -1);
1219 GTEST_LOG_(INFO) << "medialib_backup_test_ParseXml_005 end";
1220 }
1221
1222 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_StringToInt_001, TestSize.Level0)
1223 {
1224 GTEST_LOG_(INFO) << "medialib_backup_test_StringToInt_001 start";
1225 std::unique_ptr<UpgradeRestore> upgrade =
1226 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1227 string xmlPath = "";
1228 auto res = upgrade->StringToInt(xmlPath);
1229 EXPECT_EQ(res, 0);
1230 GTEST_LOG_(INFO) << "medialib_backup_test_StringToInt_001 end";
1231 }
1232
1233 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_StringToInt_002, TestSize.Level0)
1234 {
1235 GTEST_LOG_(INFO) << "medialib_backup_test_StringToInt_002 start";
1236 std::unique_ptr<UpgradeRestore> upgrade =
1237 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1238 string xmlPath = " 22e";
1239 auto res = upgrade->StringToInt(xmlPath);
1240 EXPECT_EQ(res, 0);
1241 GTEST_LOG_(INFO) << "medialib_backup_test_StringToInt_002 end";
1242 }
1243
1244 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_StringToInt_003, TestSize.Level0)
1245 {
1246 GTEST_LOG_(INFO) << "medialib_backup_test_StringToInt_003 start";
1247 std::unique_ptr<UpgradeRestore> upgrade =
1248 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1249 string xmlPath = "777777777777777777777777777777777777777777777777777";
1250 auto res = upgrade->StringToInt(xmlPath);
1251 EXPECT_EQ(res, 0);
1252 GTEST_LOG_(INFO) << "medialib_backup_test_StringToInt_003 end";
1253 }
1254
1255 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_SetValueFromMetaData, TestSize.Level0)
1256 {
1257 GTEST_LOG_(INFO) << "medialib_backup_test_SetValueFromMetaData start";
1258 std::unique_ptr<UpgradeRestore> upgrade =
1259 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1260
1261 // hasOrientation = true and fileinfo.fileType != MEDIA_TYPE_VIDEO
1262 FileInfo fileInfo;
1263 fileInfo.fileType = MEDIA_TYPE_FILE;
1264 NativeRdb::ValuesBucket valueBucket;
1265 valueBucket.PutString(PhotoColumn::PHOTO_ORIENTATION, "test");
1266 upgrade->SetValueFromMetaData(fileInfo, valueBucket);
1267 GTEST_LOG_(INFO) << "medialib_backup_test_SetValueFromMetaData end";
1268 }
1269
1270 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_GetBackupInfo, TestSize.Level0)
1271 {
1272 GTEST_LOG_(INFO) << "medialib_backup_test_GetBackupInfo start";
1273 std::unique_ptr<UpgradeRestore> upgrade =
1274 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1275
1276 string str = upgrade->GetBackupInfo();
1277 EXPECT_EQ(str, "");
1278 GTEST_LOG_(INFO) << "medialib_backup_test_GetBackupInfo end";
1279 }
1280
1281 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_InsertPhoto_empty, TestSize.Level0)
1282 {
1283 GTEST_LOG_(INFO) << "medialib_backup_test_InsertPhoto_empty start";
1284 std::unique_ptr<UpgradeRestore> upgrade =
1285 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1286
1287 // empty mediaLibraryRdb_
1288 int sceneCode = 0;
1289 int32_t sourceType = 0;
1290 vector<FileInfo> fileInfos;
1291 upgrade->mediaLibraryRdb_ = nullptr;
1292 upgrade->InsertPhoto(sceneCode, fileInfos, sourceType);
1293
1294 //normal mediaLibraryRdb_ and empty file
1295 upgrade->mediaLibraryRdb_ = photosStorePtr;
1296 upgrade->InsertPhoto(sceneCode, fileInfos, sourceType);
1297 GTEST_LOG_(INFO) << "medialib_backup_test_InsertPhoto_empty end";
1298 }
1299
1300 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_InsertPhoto_normal, TestSize.Level0)
1301 {
1302 GTEST_LOG_(INFO) << "medialib_backup_test_InsertPhoto_normal start";
1303 std::unique_ptr<UpgradeRestore> upgrade =
1304 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1305
1306 int sceneCode = 0;
1307 FileInfo fileInfo1;
1308 FileInfo fileInfo2;
1309 int32_t sourceType = SourceType::GALLERY;
1310 upgrade->mediaLibraryRdb_ = photosStorePtr;
1311
1312 vector<FileInfo> fileInfos;
1313 fileInfo1.filePath = "test";
1314 fileInfos.push_back(fileInfo1);
1315 fileInfo2.filePath = "/storage/cloud/100/files/Documents/CreateImageThumbnailTest_001.jpg";
1316 fileInfo2.cloudPath = "storage/cloud/files/Audio/10/AUD_3322/jpg";
1317 fileInfos.push_back(fileInfo2);
1318 upgrade->InsertPhoto(sceneCode, fileInfos, sourceType);
1319
1320 // insertPhoto sourceType != SourceType::GALLERY
1321 sourceType = SourceType::EXTERNAL_CAMERA;
1322 upgrade->InsertPhoto(sceneCode, fileInfos, sourceType);
1323 GTEST_LOG_(INFO) << "medialib_backup_test_InsertPhoto_normal end";
1324 }
1325
1326 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_UpdateFailedFileByFileType_image, TestSize.Level0)
1327 {
1328 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_image start";
1329 std::unique_ptr<UpgradeRestore> upgrade =
1330 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1331
1332 // type = image
1333 int32_t errCode = 0;
1334 string path = "image/";
1335 string type = STAT_TYPE_PHOTO;
1336 int32_t fileType = MediaType::MEDIA_TYPE_IMAGE;
1337 FileInfo fileInfo;
1338 fileInfo.oldPath = path;
1339
1340 upgrade->UpdateFailedFileByFileType(fileType, fileInfo, errCode);
1341 auto ret = upgrade->GetFailedFiles(type);
1342 // ret[path] = errCode
1343 EXPECT_EQ(ret[path].errorCode, to_string(errCode));
1344 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_image end";
1345 }
1346
1347 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_UpdateFailedFileByFileType_video, TestSize.Level0)
1348 {
1349 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_video start";
1350 std::unique_ptr<UpgradeRestore> upgrade =
1351 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1352
1353 // type = video
1354 int32_t errCode = 1;
1355 string path = "video/";
1356 string type = STAT_TYPE_VIDEO;
1357 int32_t fileType = MediaType::MEDIA_TYPE_VIDEO;
1358 FileInfo fileInfo;
1359 fileInfo.oldPath = path;
1360
1361 upgrade->UpdateFailedFileByFileType(fileType, fileInfo, errCode);
1362 auto ret = upgrade->GetFailedFiles(type);
1363 // ret[path] = errCode
1364 EXPECT_EQ(ret[path].errorCode, to_string(errCode));
1365 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_video end";
1366 }
1367
1368 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_UpdateFailedFileByFileType_audio, TestSize.Level0)
1369 {
1370 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_audio start";
1371 std::unique_ptr<UpgradeRestore> upgrade =
1372 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1373
1374 // type = audio
1375 int32_t errCode = -1;
1376 string path = "audio/";
1377 string type = STAT_TYPE_AUDIO;
1378 int32_t fileType = MediaType::MEDIA_TYPE_AUDIO;
1379 FileInfo fileInfo;
1380 fileInfo.oldPath = path;
1381
1382 upgrade->UpdateFailedFileByFileType(fileType, fileInfo, errCode);
1383 auto ret = upgrade->GetFailedFiles(type);
1384 // ret[path] = errCode
1385 EXPECT_EQ(ret[path].errorCode, to_string(errCode));
1386 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_audio end";
1387 }
1388
1389 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_UpdateFailedFileByFileType_illegal_filetype, TestSize.Level0)
1390 {
1391 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_illegal_filetype start";
1392 std::unique_ptr<UpgradeRestore> upgrade =
1393 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1394
1395 // illegal file type
1396 int32_t fileType = -1;
1397 string path = "test_path";
1398 int32_t errCode = 3;
1399 FileInfo fileInfo;
1400 fileInfo.oldPath = path;
1401
1402 upgrade->UpdateFailedFileByFileType(fileType, fileInfo, errCode);
1403 auto ret = upgrade->GetErrorInfoJson();
1404 string str = ret[STAT_KEY_ERROR_INFO].dump();
1405 str.erase(std::remove(str.begin(), str.end(), '\"'), str.end());
1406 EXPECT_EQ(str, "");
1407 GTEST_LOG_(INFO) << "medialib_backup_test_UpdateFailedFileByFileType_illegal_filetype end";
1408 }
1409
1410 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_SetErrorCode, TestSize.Level0)
1411 {
1412 GTEST_LOG_(INFO) << "medialib_backup_test_SetErrorCode start";
1413 std::unique_ptr<UpgradeRestore> upgrade =
1414 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1415
1416 // errCode = INIT_FAILED
1417 int32_t errCode = INIT_FAILED;
1418 upgrade->SetErrorCode(errCode);
1419 auto ret = upgrade->GetErrorInfoJson();
1420 string str = ret[STAT_KEY_ERROR_INFO].dump();
1421 str.erase(std::remove(str.begin(), str.end(), '\"'), str.end());
1422 EXPECT_EQ(str, "RESTORE_INIT_FAILED");
1423
1424 // illegal errCode
1425 errCode = 999;
1426 upgrade->SetErrorCode(errCode);
1427 ret = upgrade->GetErrorInfoJson();
1428 str = ret[STAT_KEY_ERROR_INFO].dump();
1429 str.erase(std::remove(str.begin(), str.end(), '\"'), str.end());
1430 EXPECT_EQ(str.length(), 0);
1431 GTEST_LOG_(INFO) << "medialib_backup_test_SetErrorCode end";
1432 }
1433
1434 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_GetSubCountInfo_illegal_type, TestSize.Level0)
1435 {
1436 GTEST_LOG_(INFO) << "medialib_backup_test_GetSubCountInfo_illegal_type start";
1437 std::unique_ptr<UpgradeRestore> upgrade =
1438 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1439
1440 // case 1 illegal type GetSubCountInfo will return empty failedFiles
1441 string type = "test_types";
1442 SubCountInfo ret = upgrade->GetSubCountInfo(type);
1443 EXPECT_EQ(ret.failedFiles.empty(), 1);
1444 GTEST_LOG_(INFO) << "medialib_backup_test_GetSubCountInfo_illegal_type end";
1445 }
1446
1447 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_GetCountInfoJson_empty_types, TestSize.Level0)
1448 {
1449 GTEST_LOG_(INFO) << "medialib_backup_test_GetCountInfoJson_empty_types start";
1450 std::unique_ptr<UpgradeRestore> upgrade =
1451 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1452
1453 vector<string> types;
1454 auto ret = upgrade->GetCountInfoJson(types);
1455 //json node not available will return null
1456 string str = ret[STAT_KEY_INFOS].dump();
1457 str.erase(std::remove(str.begin(), str.end(), '\"'), str.end());
1458 EXPECT_EQ(str, "null");
1459 GTEST_LOG_(INFO) << "medialib_backup_test_GetCountInfoJson_empty_types end";
1460 }
1461
1462 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_GetCountInfoJson_normal_types, TestSize.Level0)
1463 {
1464 GTEST_LOG_(INFO) << "medialib_backup_test_GetCountInfoJson_normal_types start";
1465 std::unique_ptr<UpgradeRestore> upgrade =
1466 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1467
1468 vector<string> types = STAT_TYPES;
1469 auto ret = upgrade->GetCountInfoJson(types);
1470 // stat_types[1] = video ret[1][STAT_KEY_BACKUP_INFO] = video
1471 auto str = ret[STAT_KEY_INFOS][1][STAT_KEY_BACKUP_INFO].dump();
1472 str.erase(std::remove(str.begin(), str.end(), '\"'), str.end());
1473 EXPECT_EQ(str, "video");
1474 GTEST_LOG_(INFO) << "medialib_backup_test_GetCountInfoJson_normal_types end";
1475 }
1476
1477 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_GetCountInfoJson_illegal_types, TestSize.Level0)
1478 {
1479 GTEST_LOG_(INFO) << "medialib_backup_test_GetCountInfoJson_illegal_types start";
1480 std::unique_ptr<UpgradeRestore> upgrade =
1481 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1482
1483 vector<string> types = { "test" };
1484 auto ret = upgrade->GetCountInfoJson(types);
1485 string str = ret[STAT_KEY_INFOS][0][STAT_KEY_BACKUP_INFO].dump();
1486 str.erase(std::remove(str.begin(), str.end(), '\"'), str.end());
1487 EXPECT_EQ(str, "test");
1488 GTEST_LOG_(INFO) << "medialib_backup_test_GetCountInfoJson_illegal_types end";
1489 }
1490
1491 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_need_batch_query_photo, TestSize.Level0)
1492 {
1493 GTEST_LOG_(INFO) << "medialib_backup_test_need_batch_query_photo start";
1494 std::unique_ptr<UpgradeRestore> upgrade =
1495 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, UPGRADE_RESTORE_ID);
1496 std::vector<FileInfo> fileInfos;
1497 NeedQueryMap needQueryMap;
1498 auto ret = upgrade->NeedBatchQueryPhoto(fileInfos, needQueryMap);
1499 EXPECT_EQ(ret, false);
1500 EXPECT_EQ(needQueryMap.empty(), true);
1501 GTEST_LOG_(INFO) << "medialib_backup_test_need_batch_query_photo end";
1502 }
1503
TestConvertPathToRealPathByStorageType(bool isSd)1504 void TestConvertPathToRealPathByStorageType(bool isSd)
1505 {
1506 std::string srcPath = isSd ? "/storage/ABCD-0000" : "/storage/emulated/0";
1507 srcPath += TEST_RELATIVE_PATH;
1508 FileInfo fileInfo;
1509 fileInfo.fileSize = TEST_SIZE_2MB_BELOW;
1510 fileInfo.localMediaId = TEST_LOCAL_MEDIA_ID;
1511 std::unique_ptr<UpgradeRestore> upgrade =
1512 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1513 std::string newPath;
1514 std::string relativePath;
1515 bool result = upgrade->ConvertPathToRealPath(srcPath, TEST_PATH_PREFIX, newPath, relativePath, fileInfo);
1516 EXPECT_EQ(result, true);
1517 EXPECT_EQ(newPath, TEST_PATH_PREFIX + srcPath);
1518 EXPECT_EQ(relativePath, TEST_RELATIVE_PATH);
1519 }
1520
1521 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_path_to_real_path_001, TestSize.Level0)
1522 {
1523 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_001 start";
1524 TestConvertPathToRealPathByStorageType(false); // internal, normal
1525 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_001 end";
1526 }
1527
1528 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_path_to_real_path_002, TestSize.Level0)
1529 {
1530 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_002 start";
1531 TestConvertPathToRealPathByStorageType(true); // sd card, normal
1532 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_002 end";
1533 }
1534
TestConvertPathToRealPathByFileSize(int64_t fileSize,const std::string & srcPath,const std::string & expectedNewPath)1535 void TestConvertPathToRealPathByFileSize(int64_t fileSize, const std::string &srcPath,
1536 const std::string &expectedNewPath)
1537 {
1538 FileInfo fileInfo;
1539 fileInfo.fileSize = fileSize;
1540 fileInfo.localMediaId = TEST_LOCAL_MEDIA_ID;
1541 std::unique_ptr<UpgradeRestore> upgrade =
1542 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1543 std::string newPath;
1544 std::string relativePath;
1545 bool result = upgrade->ConvertPathToRealPath(srcPath, TEST_PATH_PREFIX, newPath, relativePath, fileInfo);
1546 EXPECT_EQ(result, true);
1547 EXPECT_EQ(newPath, expectedNewPath);
1548 EXPECT_EQ(relativePath, TEST_RELATIVE_PATH);
1549 }
1550
1551 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_path_to_real_path_003, TestSize.Level0)
1552 {
1553 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_003 start";
1554 std::string srcPath = "/storage/ABCD-0000" + TEST_RELATIVE_PATH;
1555 std::string expectedNewPath = TEST_PATH_PREFIX + srcPath;
1556 TestConvertPathToRealPathByFileSize(TEST_SIZE_2MB_BELOW, srcPath, expectedNewPath); // Sd, below 2MB
1557 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_003 end";
1558 }
1559
1560 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_path_to_real_path_004, TestSize.Level0)
1561 {
1562 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_004 start";
1563 std::string srcPath = "/storage/ABCD-0000" + TEST_RELATIVE_PATH;
1564 std::string expectedNewPath = TEST_PATH_PREFIX + TEST_RELATIVE_PATH;
1565 TestConvertPathToRealPathByFileSize(TEST_SIZE_2MB, srcPath, expectedNewPath); // Sd, equal to 2MB
1566 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_004 end";
1567 }
1568
1569 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_path_to_real_path_005, TestSize.Level0)
1570 {
1571 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_005 start";
1572 std::string srcPath = "/storage/ABCD-0000" + TEST_RELATIVE_PATH;
1573 std::string expectedNewPath = TEST_PATH_PREFIX + TEST_RELATIVE_PATH;
1574 TestConvertPathToRealPathByFileSize(TEST_SIZE_2MB_ABOVE, srcPath, expectedNewPath); // Sd, above 2MB
1575 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_005 end";
1576 }
1577
TestConvertPathToRealPathByLocalMediaId(int32_t localMediaId,const std::string & srcPath,const std::string & expectedNewPath)1578 void TestConvertPathToRealPathByLocalMediaId(int32_t localMediaId, const std::string &srcPath,
1579 const std::string &expectedNewPath)
1580 {
1581 FileInfo fileInfo;
1582 fileInfo.fileSize = TEST_SIZE_2MB_ABOVE;
1583 fileInfo.localMediaId = localMediaId;
1584 std::unique_ptr<UpgradeRestore> upgrade =
1585 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1586 std::string newPath;
1587 std::string relativePath;
1588 bool result = upgrade->ConvertPathToRealPath(srcPath, TEST_PATH_PREFIX, newPath, relativePath, fileInfo);
1589 EXPECT_EQ(result, true);
1590 EXPECT_EQ(newPath, expectedNewPath);
1591 EXPECT_EQ(relativePath, TEST_RELATIVE_PATH);
1592 }
1593
1594 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_path_to_real_path_006, TestSize.Level0)
1595 {
1596 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_006 start";
1597 std::string srcPath = "/storage/ABCD-0000" + TEST_RELATIVE_PATH;
1598 std::string expectedNewPath = TEST_PATH_PREFIX + srcPath;
1599 TestConvertPathToRealPathByLocalMediaId(GALLERY_HIDDEN_ID, srcPath, expectedNewPath); // Sd, hidden
1600 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_006 end";
1601 }
1602
1603 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_path_to_real_path_007, TestSize.Level0)
1604 {
1605 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_007 start";
1606 std::string srcPath = "/storage/ABCD-0000" + TEST_RELATIVE_PATH;
1607 std::string expectedNewPath = TEST_PATH_PREFIX + srcPath;
1608 TestConvertPathToRealPathByLocalMediaId(GALLERY_TRASHED_ID, srcPath, expectedNewPath); // Sd, trashed
1609 GTEST_LOG_(INFO) << "medialib_backup_test_convert_path_to_real_path_007 end";
1610 }
1611
1612 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_get_path_pos_by_prefix_level, TestSize.Level0)
1613 {
1614 GTEST_LOG_(INFO) << "medialib_backup_test_get_path_pos_by_prefix_level start";
1615 std::string path = "/../";
1616 size_t pos = 0;
1617 bool result = BackupFileUtils::GetPathPosByPrefixLevel(DUAL_FRAME_CLONE_RESTORE_ID, path, TEST_PREFIX_LEVEL,
1618 pos);
1619 EXPECT_EQ(result, false);
1620 GTEST_LOG_(INFO) << "medialib_backup_test_get_path_pos_by_prefix_level end";
1621 }
1622
1623 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_update_duplicate_number, TestSize.Level0)
1624 {
1625 GTEST_LOG_(INFO) << "medialib_backup_test_update_duplicate_number start";
1626 std::unique_ptr<UpgradeRestore> upgrade =
1627 std::make_unique<UpgradeRestore>(GALLERY_APP_NAME, MEDIA_APP_NAME, DUAL_FRAME_CLONE_RESTORE_ID);
1628 upgrade->UpdateDuplicateNumber(MediaType::MEDIA_TYPE_IMAGE);
1629 EXPECT_GT(upgrade->migratePhotoDuplicateNumber_, 0);
1630 upgrade->UpdateDuplicateNumber(MediaType::MEDIA_TYPE_VIDEO);
1631 EXPECT_GT(upgrade->migrateVideoDuplicateNumber_, 0);
1632 upgrade->UpdateDuplicateNumber(MediaType::MEDIA_TYPE_AUDIO);
1633 EXPECT_GT(upgrade->migrateAudioDuplicateNumber_, 0);
1634 uint64_t photoBefore = upgrade->migratePhotoDuplicateNumber_;
1635 uint64_t videoBefore = upgrade->migrateVideoDuplicateNumber_;
1636 uint64_t audioBefore = upgrade->migrateAudioDuplicateNumber_;
1637 upgrade->UpdateDuplicateNumber(-1);
1638 EXPECT_EQ(upgrade->migratePhotoDuplicateNumber_, photoBefore);
1639 EXPECT_EQ(upgrade->migrateVideoDuplicateNumber_, videoBefore);
1640 EXPECT_EQ(upgrade->migrateAudioDuplicateNumber_, audioBefore);
1641 GTEST_LOG_(INFO) << "medialib_backup_test_update_duplicate_number end";
1642 }
1643
1644 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_update_sd_where_clause, TestSize.Level0)
1645 {
1646 GTEST_LOG_(INFO) << "medialib_backup_test_update_sd_where_clause start";
1647 std::string whereClause;
1648 BackupDatabaseUtils::UpdateSdWhereClause(whereClause, true);
1649 EXPECT_EQ(whereClause.empty(), true);
1650 BackupDatabaseUtils::UpdateSdWhereClause(whereClause, false);
1651 EXPECT_EQ(whereClause.empty(), false);
1652 GTEST_LOG_(INFO) << "medialib_backup_test_update_sd_where_clause end";
1653 }
1654
1655 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_get_landmarks_scale_001, TestSize.Level0)
1656 {
1657 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_001 start";
1658 int length = TEST_SIZE_MIN; // (0, 2 * min), no need to scale
1659 float scale = BackupDatabaseUtils::GetLandmarksScale(length, length);
1660 EXPECT_EQ(scale, 1);
1661 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_001 end";
1662 }
1663
1664 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_get_landmarks_scale_002, TestSize.Level0)
1665 {
1666 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_002 start";
1667 int length = TEST_SIZE_MIN * TEST_SIZE_MULT_UNIT + TEST_SIZE_INCR_UNIT; // [2 * min, 4 * min)
1668 float scale = BackupDatabaseUtils::GetLandmarksScale(length, length);
1669 float expectedScale = 1.0 / TEST_SIZE_MULT_UNIT;
1670 EXPECT_EQ(scale, expectedScale);
1671 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_002 end";
1672 }
1673
1674 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_get_landmarks_scale_003, TestSize.Level0)
1675 {
1676 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_003 start";
1677 int length = TEST_SIZE_MIN * TEST_SIZE_MULT_UNIT * TEST_SIZE_MULT_UNIT; // [4 * min, ...)
1678 float scale = BackupDatabaseUtils::GetLandmarksScale(length, length);
1679 float expectedScale = 1.0 / TEST_SIZE_MULT_UNIT / TEST_SIZE_MULT_UNIT;
1680 EXPECT_EQ(scale, expectedScale);
1681 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_003 end";
1682 }
1683
1684 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_get_landmarks_scale_004, TestSize.Level0)
1685 {
1686 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_004 start";
1687 int width = TEST_SIZE_MIN;
1688 int height = TEST_SIZE_MAX * TEST_SIZE_MULT_UNIT; // max len exceeds
1689 float scale = BackupDatabaseUtils::GetLandmarksScale(width, height);
1690 float expectedScale = 1.0 / TEST_SIZE_MULT_UNIT;
1691 EXPECT_EQ(scale, expectedScale);
1692 GTEST_LOG_(INFO) << "medialib_backup_test_get_landmarks_scale_004 end";
1693 }
1694
InitFaceInfoScale(FaceInfo & faceInfo,float scaleX,float scaleY,float scaleWidth,float scaleHeight)1695 void InitFaceInfoScale(FaceInfo &faceInfo, float scaleX, float scaleY, float scaleWidth, float scaleHeight)
1696 {
1697 faceInfo.scaleX = scaleX;
1698 faceInfo.scaleY = scaleY;
1699 faceInfo.scaleWidth = scaleWidth;
1700 faceInfo.scaleHeight = scaleHeight;
1701 }
1702
1703 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_is_landmark_valid_001, TestSize.Level0)
1704 {
1705 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_001 start";
1706 FaceInfo faceInfo;
1707 InitFaceInfoScale(faceInfo, TEST_SCALE_MIN, TEST_SCALE_MIN, TEST_SCALE_MAX - TEST_SCALE_MIN,
1708 TEST_SCALE_MAX - TEST_SCALE_MIN);
1709 bool result = BackupDatabaseUtils::IsLandmarkValid(faceInfo, TEST_LANDMARK_BETWEEN, TEST_LANDMARK_BETWEEN);
1710 EXPECT_EQ(result, true);
1711 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_001 end";
1712 }
1713
1714 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_is_landmark_valid_002, TestSize.Level0)
1715 {
1716 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_002 start";
1717 FaceInfo faceInfo;
1718 InitFaceInfoScale(faceInfo, TEST_SCALE_MIN, TEST_SCALE_MIN, TEST_SCALE_MAX - TEST_SCALE_MIN,
1719 TEST_SCALE_MAX - TEST_SCALE_MIN);
1720 bool result = BackupDatabaseUtils::IsLandmarkValid(faceInfo, TEST_LANDMARK_BETWEEN, TEST_LANDMARK_BELOW);
1721 EXPECT_EQ(result, false);
1722 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_002 end";
1723 }
1724
1725 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_is_landmark_valid_003, TestSize.Level0)
1726 {
1727 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_003 start";
1728 FaceInfo faceInfo;
1729 InitFaceInfoScale(faceInfo, TEST_SCALE_MIN, TEST_SCALE_MIN, TEST_SCALE_MAX - TEST_SCALE_MIN,
1730 TEST_SCALE_MAX - TEST_SCALE_MIN);
1731 bool result = BackupDatabaseUtils::IsLandmarkValid(faceInfo, TEST_LANDMARK_BETWEEN, TEST_LANDMARK_ABOVE);
1732 EXPECT_EQ(result, false);
1733 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_003 end";
1734 }
1735
1736 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_is_landmark_valid_004, TestSize.Level0)
1737 {
1738 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_004 start";
1739 FaceInfo faceInfo;
1740 InitFaceInfoScale(faceInfo, TEST_SCALE_MIN, TEST_SCALE_MIN, TEST_SCALE_MAX - TEST_SCALE_MIN,
1741 TEST_SCALE_MAX - TEST_SCALE_MIN);
1742 bool result = BackupDatabaseUtils::IsLandmarkValid(faceInfo, TEST_LANDMARK_BELOW, TEST_LANDMARK_BETWEEN);
1743 EXPECT_EQ(result, false);
1744 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_004 end";
1745 }
1746
1747 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_is_landmark_valid_005, TestSize.Level0)
1748 {
1749 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_005 start";
1750 FaceInfo faceInfo;
1751 InitFaceInfoScale(faceInfo, TEST_SCALE_MIN, TEST_SCALE_MIN, TEST_SCALE_MAX - TEST_SCALE_MIN,
1752 TEST_SCALE_MAX - TEST_SCALE_MIN);
1753 bool result = BackupDatabaseUtils::IsLandmarkValid(faceInfo, TEST_LANDMARK_ABOVE, TEST_LANDMARK_BETWEEN);
1754 EXPECT_EQ(result, false);
1755 GTEST_LOG_(INFO) << "medialib_backup_test_is_landmark_valid_005 end";
1756 }
1757
ExecuteSqls(shared_ptr<RdbStore> rdbStore,const vector<string> & sqls)1758 void ExecuteSqls(shared_ptr<RdbStore> rdbStore, const vector<string> &sqls)
1759 {
1760 for (const auto &sql : sqls) {
1761 int32_t errCode = rdbStore->ExecuteSql(sql);
1762 if (errCode == E_OK) {
1763 continue;
1764 }
1765 MEDIA_ERR_LOG("Execute %{public}s failed: %{public}d", sql.c_str(), errCode);
1766 }
1767 }
1768
ClearData(shared_ptr<RdbStore> rdbStore)1769 void ClearData(shared_ptr<RdbStore> rdbStore)
1770 {
1771 MEDIA_INFO_LOG("Start clear data");
1772 ExecuteSqls(rdbStore, CLEAR_SQLS);
1773 MediaLibraryUnitTestUtils::InitUnistore();
1774 auto mediaLibraryRdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
1775 MediaLibraryRdbUtils::UpdateAllAlbums(mediaLibraryRdbStore);
1776 MEDIA_INFO_LOG("End clear data");
1777 }
1778
InsertPhoto(unique_ptr<UpgradeRestore> & upgrade,vector<FileInfo> & fileInfos)1779 void InsertPhoto(unique_ptr<UpgradeRestore> &upgrade, vector<FileInfo> &fileInfos)
1780 {
1781 // Photo
1782 for (auto &fileInfo : fileInfos) {
1783 fileInfo.cloudPath = TEST_CLOUD_PATH_PREFIX + fileInfo.displayName;
1784 ValuesBucket values = upgrade->GetInsertValue(fileInfo, fileInfo.cloudPath, SourceType::GALLERY);
1785 int64_t rowNum = 0;
1786 if (upgrade->mediaLibraryRdb_->Insert(rowNum, PhotoColumn::PHOTOS_TABLE, values) != E_OK) {
1787 MEDIA_ERR_LOG("InsertSql failed, filePath = %{public}s", fileInfo.filePath.c_str());
1788 }
1789 }
1790 // Photo related
1791 upgrade->InsertPhotoRelated(fileInfos, SourceType::GALLERY);
1792 }
1793
RestorePhotoWithPortrait(unique_ptr<UpgradeRestore> & upgrade)1794 void RestorePhotoWithPortrait(unique_ptr<UpgradeRestore> &upgrade)
1795 {
1796 vector<FileInfo> fileInfos = upgrade->QueryFileInfos(0);
1797 InsertPhoto(upgrade, fileInfos);
1798 upgrade->UpdateFaceAnalysisStatus();
1799 }
1800
QueryInt(shared_ptr<RdbStore> rdbStore,const string & querySql,const string & columnName,int32_t & result)1801 void QueryInt(shared_ptr<RdbStore> rdbStore, const string &querySql, const string &columnName,
1802 int32_t &result)
1803 {
1804 ASSERT_NE(rdbStore, nullptr);
1805 auto resultSet = rdbStore->QuerySql(querySql);
1806 ASSERT_NE(resultSet, nullptr);
1807 ASSERT_EQ(resultSet->GoToFirstRow(), E_OK);
1808 result = GetInt32Val(columnName, resultSet);
1809 MEDIA_INFO_LOG("Query %{public}s result: %{public}d", querySql.c_str(), result);
1810 }
1811
QueryPortraitAlbumCount(shared_ptr<RdbStore> rdbStore,int32_t & result)1812 void QueryPortraitAlbumCount(shared_ptr<RdbStore> rdbStore, int32_t &result)
1813 {
1814 string querySql = "SELECT count(DISTINCT group_tag) AS count FROM AnalysisAlbum WHERE album_type = 4096 AND \
1815 album_subtype = 4102";
1816 QueryInt(rdbStore, querySql, "count", result);
1817 }
1818
QueryPortraitTagCount(shared_ptr<RdbStore> rdbStore,int32_t & result)1819 void QueryPortraitTagCount(shared_ptr<RdbStore> rdbStore, int32_t &result)
1820 {
1821 string querySql = "SELECT count(1) as count FROM tab_analysis_face_tag";
1822 QueryInt(rdbStore, querySql, "count", result);
1823 }
1824
QueryPortraitPhotoCount(shared_ptr<RdbStore> rdbStore,int32_t & result)1825 void QueryPortraitPhotoCount(shared_ptr<RdbStore> rdbStore, int32_t &result)
1826 {
1827 string querySql = "SELECT count(DISTINCT file_id) as count FROM tab_analysis_image_face";
1828 QueryInt(rdbStore, querySql, "count", result);
1829 }
1830
QueryPortraitFaceCount(shared_ptr<RdbStore> rdbStore,int32_t & result)1831 void QueryPortraitFaceCount(shared_ptr<RdbStore> rdbStore, int32_t &result)
1832 {
1833 string querySql = "SELECT count(1) as count FROM tab_analysis_image_face";
1834 QueryInt(rdbStore, querySql, "count", result);
1835 }
1836
QueryPortraitTotalCount(shared_ptr<RdbStore> rdbStore,int32_t & result)1837 void QueryPortraitTotalCount(shared_ptr<RdbStore> rdbStore, int32_t &result)
1838 {
1839 string querySql = "SELECT count(1) as count FROM tab_analysis_total WHERE face > 0";
1840 QueryInt(rdbStore, querySql, "count", result);
1841 }
1842
1843 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_is_livephoto, TestSize.Level0)
1844 {
1845 MEDIA_INFO_LOG("medialib_backup_test_is_livephoto start");
1846 FileInfo info;
1847 info.specialFileType = 50;
1848 EXPECT_EQ(BackupFileUtils::IsLivePhoto(info), true);
1849 info.specialFileType = 1050;
1850 EXPECT_EQ(BackupFileUtils::IsLivePhoto(info), true);
1851 info.specialFileType = 0;
1852 EXPECT_EQ(BackupFileUtils::IsLivePhoto(info), false);
1853 info.specialFileType = 1000;
1854 EXPECT_EQ(BackupFileUtils::IsLivePhoto(info), false);
1855 info.specialFileType = -50;
1856 EXPECT_EQ(BackupFileUtils::IsLivePhoto(info), false);
1857 MEDIA_INFO_LOG("medialib_backup_test_is_livephoto end");
1858 }
1859
1860 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_convert_to_moving_photo, TestSize.Level0)
1861 {
1862 MEDIA_INFO_LOG("medialib_backup_test_convert_to_moving_photo start");
1863 string livePhotoPath = "/data/test/backup_test_livephoto.jpg";
1864 EXPECT_EQ(MediaFileUtils::CreateDirectory("/data/test/"), true);
1865 EXPECT_EQ(MediaFileUtils::CreateFile(livePhotoPath), true);
1866
1867 FileInfo info;
1868 info.filePath = livePhotoPath;
1869 BackupFileUtils::ConvertToMovingPhoto(info);
1870 EXPECT_EQ(info.movingPhotoVideoPath, "/data/test/backup_test_livephoto.jpg.mp4");
1871 EXPECT_EQ(info.extraDataPath, "/data/test/backup_test_livephoto.jpg.extra");
1872
1873 info.filePath = livePhotoPath;
1874 EXPECT_EQ(MediaFileUtils::CreateFile(info.movingPhotoVideoPath), true);
1875 EXPECT_EQ(MediaFileUtils::CreateFile(info.extraDataPath), true);
1876 BackupFileUtils::ConvertToMovingPhoto(info);
1877 EXPECT_EQ(info.movingPhotoVideoPath, "/data/test/backup_test_livephoto.jpg.mp4.dup.mp4");
1878 EXPECT_EQ(info.extraDataPath, "/data/test/backup_test_livephoto.jpg.extra.dup.extra");
1879 MEDIA_INFO_LOG("medialib_backup_test_convert_to_moving_photo end");
1880 }
1881
1882 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_file_access_helper, TestSize.Level0)
1883 {
1884 MEDIA_INFO_LOG("medialib_backup_test_file_access_helper start");
1885 string backupFilePath = "/data/test/Pictures/Camera/Flower.png";
1886 EXPECT_EQ(MediaFileUtils::CreateDirectory("/data/test/Pictures/Camera/"), true);
1887 EXPECT_EQ(MediaFileUtils::CreateFile(backupFilePath), true);
1888
1889 string lowerCasePath = "/data/test/pictures/camera/flower.png";
1890 EXPECT_EQ(-1, access(lowerCasePath.c_str(), F_OK));
1891
1892 std::shared_ptr<FileAccessHelper> fileAccessHelper_ = std::make_shared<FileAccessHelper>();
1893 string resultPath = lowerCasePath;
1894 bool res = fileAccessHelper_->GetValidPath(resultPath);
1895 EXPECT_EQ(true, res);
1896 EXPECT_EQ(backupFilePath, resultPath);
1897
1898 resultPath = "/data/test/Pictures/Camera/FlowerNOT.png";
1899 res = fileAccessHelper_->GetValidPath(resultPath);
1900 EXPECT_EQ(false, res);
1901
1902 MEDIA_INFO_LOG("medialib_backup_test_file_access_helper end");
1903 }
1904
1905 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_media_type_beyong_1_3, TestSize.Level0)
1906 {
1907 MEDIA_INFO_LOG("medialib_backup_test_media_type start");
1908 PhotosRestore photosRestore;
1909 FileInfo fileInfo;
1910 fileInfo.displayName = "abc.jpg";
1911 MimeTypeUtils::InitMimeTypeMap();
1912 EXPECT_EQ(photosRestore.FindMediaType(fileInfo), MediaType::MEDIA_TYPE_IMAGE);
1913 fileInfo.displayName = "abc.mp4";
1914 EXPECT_EQ(photosRestore.FindMediaType(fileInfo), MediaType::MEDIA_TYPE_VIDEO);
1915 fileInfo.fileType = 1;
1916 fileInfo.displayName = "abc.mp4";
1917 EXPECT_EQ(photosRestore.FindMediaType(fileInfo), MediaType::MEDIA_TYPE_IMAGE);
1918 fileInfo.fileType = 3;
1919 fileInfo.displayName = "abc.jpg";
1920 EXPECT_EQ(photosRestore.FindMediaType(fileInfo), MediaType::MEDIA_TYPE_VIDEO);
1921 MEDIA_INFO_LOG("medialib_backup_test_media_type end");
1922 }
1923
TestAppTwinData(const string & path,const string & expectedExtraPrefix,int32_t sceneCode=UPGRADE_RESTORE_ID)1924 void TestAppTwinData(const string &path, const string &expectedExtraPrefix, int32_t sceneCode = UPGRADE_RESTORE_ID)
1925 {
1926 string extraPrefix = BackupFileUtils::GetExtraPrefixForRealPath(sceneCode, path);
1927 MEDIA_INFO_LOG("path: %{public}s, extraPrefix: %{public}s", path.c_str(), extraPrefix.c_str());
1928 EXPECT_EQ(extraPrefix, expectedExtraPrefix);
1929 }
1930
1931 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_001, TestSize.Level0)
1932 {
1933 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_001 start");
1934 TestAppTwinData("", "", CLONE_RESTORE_ID); // not upgrade
1935 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_001 end");
1936 }
1937
1938 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_002, TestSize.Level0)
1939 {
1940 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_002 start");
1941 TestAppTwinData("", ""); // not app twin data: empty
1942 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_002 end");
1943 }
1944
1945 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_003, TestSize.Level0)
1946 {
1947 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_003 start");
1948 TestAppTwinData("/storage/ABCE-EFGH/0/", ""); // not app twin data: external
1949 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_003 end");
1950 }
1951
1952 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_004, TestSize.Level0)
1953 {
1954 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_004 start");
1955 TestAppTwinData("/storage/emulated/0/", ""); // not app twin data: main user
1956 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_004 end");
1957 }
1958
1959 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_005, TestSize.Level0)
1960 {
1961 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_005 start");
1962 TestAppTwinData("/storage/emulated", ""); // not app twin data: first / not found
1963 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_005 end");
1964 }
1965
1966 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_006, TestSize.Level0)
1967 {
1968 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_006 start");
1969 TestAppTwinData("/storage/emulated/", ""); // not app twin data: second / not found
1970 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_006 end");
1971 }
1972
1973 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_007, TestSize.Level0)
1974 {
1975 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_007 start");
1976 TestAppTwinData("/storage/emulated/abc/", ""); // not app twin data: not number
1977 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_007 end");
1978 }
1979
1980 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_008, TestSize.Level0)
1981 {
1982 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_008 start");
1983 TestAppTwinData("/storage/emulated/1234/", ""); // not app twin data: not in [128, 147]
1984 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_008 end");
1985 }
1986
1987 HWTEST_F(MediaLibraryBackupTest, medialib_backup_test_app_twin_data_009, TestSize.Level0)
1988 {
1989 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_009 start");
1990 TestAppTwinData("/storage/emulated/128/", APP_TWIN_DATA_PREFIX); // app twin data
1991 MEDIA_INFO_LOG("medialib_backup_test_app_twin_data_009 end");
1992 }
1993 } // namespace Media
1994 } // namespace OHOS
