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 "AssetAccurateRefreshTest"
17 #include "asset_accurate_refresh_test.h"
18
19 #include <chrono>
20 #include <thread>
21
22 #include "medialibrary_rdbstore.h"
23 #include "medialibrary_unistore_manager.h"
24 #include "medialibrary_data_manager.h"
25 #include "medialibrary_unittest_utils.h"
26 #include "medialibrary_type_const.h"
27
28 #include "accurate_debug_log.h"
29 #define protected public
30 #define private public
31 #include "asset_accurate_refresh.h"
32 #include "multi_thread_asset_change_info_mgr.h"
33 #undef protected
34 #undef private
35
36 #include "accurate_refresh_test_util.h"
37
38 namespace OHOS {
39 namespace Media {
40 using namespace std;
41 using namespace testing::ext;
42 using namespace OHOS::NativeRdb;
43 using namespace AccurateRefresh;
44
45 static shared_ptr<MediaLibraryRdbStore> g_rdbStore;
46
47 static constexpr int32_t SLEEP_FIVE_SECONDS = 5;
48
49 namespace {
50 // 新增
51 // 普通资产（收藏、视频、隐藏、图片）
52
53 const int32_t ASSET_FILE_ID = 0; // 数据库插入后才有值
54 const string ASSET_URI = "uri"; // 跟file_id关联
55 const string ASSET_DATE_DAY = "20250525";
56 const int64_t ASSET_DATE_TRASH = 123451234567;
57 const int32_t ASSET_MEDIA_TYPE_VIDEO = static_cast<int32_t>(MEDIA_TYPE_VIDEO);
58 const int32_t ASSET_MEDIA_TYPE_IMAGE = static_cast<int32_t>(MEDIA_TYPE_IMAGE);
59 const int32_t ASSET_STRONG_ASSOCIATION_NORMAL = static_cast<int32_t>(StrongAssociationType::NORMAL);
60 const int32_t ASSET_STRONG_ASSOCIATION_CLOUD = static_cast<int32_t>(StrongAssociationType::CLOUD_ENHANCEMENT);
61 const int32_t ASSET_THUMBNAIL_VISIBLE = 1;
62 const int64_t ASSET_DATE_ADDED = 123456;
63 const int64_t ASSET_DATE_TAKEN = 123456;
64 const int32_t ASSET_SUBTYPE_DEFAULT = static_cast<int32_t>(PhotoSubType::DEFAULT);
65 const int32_t ASSET_SYNC_STATUS_VISIBLE = static_cast<int32_t>(SyncStatusType::TYPE_VISIBLE);
66 const int32_t ASSET_CLEAN_FLAG_NO = static_cast<int32_t>(CleanType::TYPE_NOT_CLEAN);
67 const int32_t ASSET_BURST_COVER_LEVEL = static_cast<int32_t>(BurstCoverLevelType::COVER);
68 const string ASSET_DISPLAY_NAME = "asset_display_name";
69 const string ASSET_PATH = "asset_path";
70 const string OWNER_ALBUM_URI_ = "file://media/PhotoAlbum/";
71 const int64_t ASSET_HIDDEN_TIME = 54321;
72
73 const int32_t FAVORITE_VIDEO_ASSET_ALBUM_ID = 100;
74 const int32_t FAVORITE_VIDEO_ASSET_FILE_ID = 10000;
75
76 const int32_t VIDEO_ASSET_ALBUM_ID = 200;
77 const int32_t VIDEO_ASSET_FILE_ID = 2000;
78
79 const int32_t FAVORITE_IMAGE_ASSET_ALBUM_ID = 300;
80 const int32_t FAVORITE_IMAGE_ASSET_FILE_ID = 30000;
81
82 const int32_t IMAGE_ASSET_ALBUM_ID = 400;
83 const int32_t IMAGE_ASSET_FILE_ID = 40000;
84
85 const int32_t FAVORITE_VIDEO_HIDDEN_ASSET_ALBUM_ID = 500;
86 const int32_t FAVORITE_VIDEO_HIDDEN_ASSET_FILE_ID = 50000;
87
88 const int32_t VIDEO_HIDDEN_ASSET_ALBUM_ID = 600;
89
90 const int32_t FAVORITE_IMAGE_HIDDEN_ASSET_ALBUM_ID = 700;
91
92 const int32_t IMAGE_HIDDEN_ASSET_ALBUM_ID = 800;
93
94 const int32_t IMAGE_CLOUD_ASSET_ALBUM_ID = 900;
95 const int32_t IMAGE_CLOUD_ASSET_FILE_ID = 90000;
96
97 const int32_t IMAGE_TRASH_ASSET_ALBUM_ID = 1000;
98 const int32_t IMAGE_TRASH_ASSET_FILE_ID = 100000;
99
100 const PhotoAssetChangeInfo NORMAL_ASSET = { ASSET_FILE_ID, ASSET_URI, ASSET_DATE_DAY,
101 "uri", // owner album uri
102 false, // isFavorite
103 ASSET_MEDIA_TYPE_IMAGE, // default image
104 false, // isHidden
105 0, // dateTrash
106 ASSET_STRONG_ASSOCIATION_NORMAL,
107 ASSET_THUMBNAIL_VISIBLE, ASSET_DATE_ADDED, ASSET_DATE_TAKEN, ASSET_SUBTYPE_DEFAULT, ASSET_SYNC_STATUS_VISIBLE,
108 ASSET_CLEAN_FLAG_NO,
109 0, // timePending
110 false, // isTemp
111 ASSET_BURST_COVER_LEVEL,
112 0, // owner album id
113 0, // hidden time
114 0,
115 ASSET_DISPLAY_NAME,
116 ASSET_PATH,
117 1, // local
118 666 //size
119 };
120
SetTables()121 void SetTables()
122 {
123 // 创建Photos/PhotoAlbum表
124 vector<string> createTableSqlList = {
125 CREATE_PHOTO_ALBUM_TABLE,
126 CREATE_PHOTO_TABLE,
127 };
128 for (auto &createTableSql : createTableSqlList) {
129 if (g_rdbStore == nullptr) {
130 MEDIA_ERR_LOG("can not get g_rdbstore");
131 return;
132 }
133 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
134 if (ret != E_OK) {
135 MEDIA_ERR_LOG("Execute sql %{private}s failed", createTableSql.c_str());
136 return;
137 }
138 MEDIA_INFO_LOG("Execute sql %{private}s success", createTableSql.c_str());
139 }
140 MEDIA_INFO_LOG("SetTables");
141 }
142
PrepareAlbumData()143 void PrepareAlbumData()
144 {
145 vector<ValuesBucket> values;
146 values.push_back(GetFavoriteInsertAlbum());
147 auto timestamp = AlbumAccurateRefreshManager::GetInstance().GetCurrentRefreshTag();
148 AlbumRefreshTimestamp albumTimestamp(timestamp, timestamp);
149 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, true, albumTimestamp);
150 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, false, albumTimestamp);
151
152 values.push_back(GetHiddenInsertAlbum());
153 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(HIDDEN_ALBUM_ID, true, albumTimestamp);
154 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(HIDDEN_ALBUM_ID, false, albumTimestamp);
155
156 values.push_back(GetTrashInsertAlbum());
157 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(TRASH_ALBUM_ID, true, albumTimestamp);
158 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(TRASH_ALBUM_ID, false, albumTimestamp);
159
160 values.push_back(GetVideoInsertAlbum());
161 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(VIDEO_ALBUM_ID, true, albumTimestamp);
162 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(VIDEO_ALBUM_ID, false, albumTimestamp);
163
164 values.push_back(GetImageInsertAlbum());
165 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_ALBUM_ID, true, albumTimestamp);
166 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_ALBUM_ID, false, albumTimestamp);
167
168 values.push_back(GetCloudEnhancementInsertAlbum());
169 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(CLOUD_ENHANCEMENT_ALBUM_ID, true, albumTimestamp);
170 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(CLOUD_ENHANCEMENT_ALBUM_ID, false, albumTimestamp);
171
172 values.push_back(GetUserInsertAlbum(FAVORITE_VIDEO_ASSET_ALBUM_ID));
173 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_VIDEO_ASSET_ALBUM_ID, true, albumTimestamp);
174 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_VIDEO_ASSET_ALBUM_ID, false,
175 albumTimestamp);
176
177 values.push_back(GetUserInsertAlbum(VIDEO_ASSET_ALBUM_ID));
178 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(VIDEO_ASSET_ALBUM_ID, true, albumTimestamp);
179 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(VIDEO_ASSET_ALBUM_ID, false, albumTimestamp);
180
181 values.push_back(GetUserInsertAlbum(FAVORITE_IMAGE_ASSET_ALBUM_ID));
182 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_IMAGE_ASSET_ALBUM_ID, true, albumTimestamp);
183 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_IMAGE_ASSET_ALBUM_ID, false,
184 albumTimestamp);
185
186 values.push_back(GetUserInsertAlbum(IMAGE_ASSET_ALBUM_ID));
187 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_ASSET_ALBUM_ID, true, albumTimestamp);
188 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_ASSET_ALBUM_ID, false, albumTimestamp);
189
190 values.push_back(GetUserInsertAlbum(FAVORITE_VIDEO_HIDDEN_ASSET_ALBUM_ID));
191 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_VIDEO_HIDDEN_ASSET_ALBUM_ID, true,
192 albumTimestamp);
193 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_VIDEO_HIDDEN_ASSET_ALBUM_ID, false,
194 albumTimestamp);
195
196 values.push_back(GetUserInsertAlbum(VIDEO_HIDDEN_ASSET_ALBUM_ID));
197 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(VIDEO_HIDDEN_ASSET_ALBUM_ID, true, albumTimestamp);
198 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(VIDEO_HIDDEN_ASSET_ALBUM_ID, false, albumTimestamp);
199
200 values.push_back(GetUserInsertAlbum(FAVORITE_IMAGE_HIDDEN_ASSET_ALBUM_ID));
201 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_IMAGE_HIDDEN_ASSET_ALBUM_ID, true,
202 albumTimestamp);
203 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_IMAGE_HIDDEN_ASSET_ALBUM_ID, false,
204 albumTimestamp);
205
206 values.push_back(GetUserInsertAlbum(IMAGE_HIDDEN_ASSET_ALBUM_ID));
207 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_HIDDEN_ASSET_ALBUM_ID, true, albumTimestamp);
208 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_HIDDEN_ASSET_ALBUM_ID, false, albumTimestamp);
209
210 values.push_back(GetUserInsertAlbum(IMAGE_CLOUD_ASSET_ALBUM_ID));
211 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_CLOUD_ASSET_ALBUM_ID, true, albumTimestamp);
212 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_CLOUD_ASSET_ALBUM_ID, false, albumTimestamp);
213
214 values.push_back(GetUserInsertAlbum(IMAGE_TRASH_ASSET_ALBUM_ID));
215 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_TRASH_ASSET_ALBUM_ID, true, albumTimestamp);
216 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_TRASH_ASSET_ALBUM_ID, false, albumTimestamp);
217
218 int64_t insertNums = 0;
219 auto ret = g_rdbStore->BatchInsert(insertNums, PhotoAlbumColumns::TABLE, values);
220 ACCURATE_DEBUG("ret: %{public}d, insert values: %{public}" PRId64, ret, insertNums);
221 }
222
CleanTestTables()223 void CleanTestTables()
224 {
225 vector<string> dropTableList = {
226 PhotoAlbumColumns::TABLE,
227 PhotoColumn::PHOTOS_TABLE,
228 };
229 for (auto &dropTable : dropTableList) {
230 string dropSql = "DROP TABLE " + dropTable + ";";
231 int32_t ret = g_rdbStore->ExecuteSql(dropSql);
232 if (ret != E_OK) {
233 MEDIA_ERR_LOG("Drop %{public}s table failed", dropTable.c_str());
234 return;
235 }
236 MEDIA_INFO_LOG("Drop %{public}s table success", dropTable.c_str());
237 }
238 }
239
240 // 收藏、视频、非隐藏
GetFavoriteVideoAsset()241 PhotoAssetChangeInfo GetFavoriteVideoAsset()
242 {
243 PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
244 assetChangeInfo.isFavorite_ = true;
245 assetChangeInfo.fileId_ = FAVORITE_VIDEO_ASSET_FILE_ID;
246 assetChangeInfo.ownerAlbumId_ = FAVORITE_VIDEO_ASSET_ALBUM_ID;
247 assetChangeInfo.ownerAlbumUri_ = OWNER_ALBUM_URI_ + to_string(FAVORITE_VIDEO_ASSET_ALBUM_ID);
248 assetChangeInfo.mediaType_ = ASSET_MEDIA_TYPE_VIDEO;
249
250 return assetChangeInfo;
251 }
252
253 // 非收藏、视频、非隐藏
GetVideoAsset()254 PhotoAssetChangeInfo GetVideoAsset()
255 {
256 PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
257 assetChangeInfo.fileId_ = VIDEO_ASSET_FILE_ID;
258 assetChangeInfo.ownerAlbumId_ = VIDEO_ASSET_ALBUM_ID;
259 assetChangeInfo.ownerAlbumUri_ = OWNER_ALBUM_URI_ + to_string(VIDEO_ASSET_ALBUM_ID);
260 assetChangeInfo.mediaType_ = ASSET_MEDIA_TYPE_VIDEO;
261 return assetChangeInfo;
262 }
263
264 // 收藏、图片(MEDIA_TYPE_IMAGE)、非隐藏
GetFavoriteImageAsset()265 PhotoAssetChangeInfo GetFavoriteImageAsset()
266 {
267 PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
268 assetChangeInfo.isFavorite_ = true;
269 assetChangeInfo.fileId_ = FAVORITE_IMAGE_ASSET_FILE_ID;
270 assetChangeInfo.ownerAlbumId_ = FAVORITE_IMAGE_ASSET_ALBUM_ID;
271 assetChangeInfo.ownerAlbumUri_ = OWNER_ALBUM_URI_ + to_string(FAVORITE_IMAGE_ASSET_ALBUM_ID);
272 return assetChangeInfo;
273 }
274
275 // 非收藏、图片、非隐藏
GetImageAsset()276 PhotoAssetChangeInfo GetImageAsset()
277 {
278 PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
279 assetChangeInfo.fileId_ = IMAGE_ASSET_FILE_ID;
280 assetChangeInfo.ownerAlbumId_ = IMAGE_ASSET_ALBUM_ID;
281 assetChangeInfo.ownerAlbumUri_ = OWNER_ALBUM_URI_ + to_string(IMAGE_ASSET_ALBUM_ID);
282 return assetChangeInfo;
283 }
284
285 // 收藏、视频、隐藏
GetFavoriteVideoHiddenAsset()286 PhotoAssetChangeInfo GetFavoriteVideoHiddenAsset()
287 {
288 PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
289 assetChangeInfo.isFavorite_ = true;
290 assetChangeInfo.fileId_ = FAVORITE_VIDEO_HIDDEN_ASSET_FILE_ID;
291 assetChangeInfo.ownerAlbumId_ = FAVORITE_VIDEO_HIDDEN_ASSET_ALBUM_ID;
292 assetChangeInfo.ownerAlbumUri_ = OWNER_ALBUM_URI_ + to_string(FAVORITE_VIDEO_HIDDEN_ASSET_ALBUM_ID);
293 assetChangeInfo.mediaType_ = ASSET_MEDIA_TYPE_VIDEO;
294 assetChangeInfo.isHidden_ = true;
295 assetChangeInfo.hiddenTime_ = ASSET_HIDDEN_TIME;
296 return assetChangeInfo;
297 }
298
299 // 云同步资产
GetCloudAsset()300 PhotoAssetChangeInfo GetCloudAsset()
301 {
302 PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
303 assetChangeInfo.fileId_ = IMAGE_CLOUD_ASSET_FILE_ID;
304 assetChangeInfo.ownerAlbumId_ = IMAGE_CLOUD_ASSET_ALBUM_ID;
305 assetChangeInfo.ownerAlbumUri_ = OWNER_ALBUM_URI_ + to_string(IMAGE_HIDDEN_ASSET_ALBUM_ID);
306 assetChangeInfo.strongAssociation_ = ASSET_STRONG_ASSOCIATION_CLOUD;
307 return assetChangeInfo;
308 }
309
310 // 回收站资产
GetTrashAsset()311 PhotoAssetChangeInfo GetTrashAsset()
312 {
313 PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
314 assetChangeInfo.fileId_ = IMAGE_TRASH_ASSET_FILE_ID;
315 assetChangeInfo.ownerAlbumId_ = IMAGE_TRASH_ASSET_ALBUM_ID;
316 assetChangeInfo.ownerAlbumUri_ = OWNER_ALBUM_URI_ + to_string(IMAGE_HIDDEN_ASSET_ALBUM_ID);
317 assetChangeInfo.dateTrashedMs_ = ASSET_DATE_TRASH;
318 return assetChangeInfo;
319 }
320
GetAssetInsertValue(PhotoAssetChangeInfo assetInfo)321 ValuesBucket GetAssetInsertValue(PhotoAssetChangeInfo assetInfo)
322 {
323 ValuesBucket value;
324 value.PutInt(PhotoColumn::MEDIA_ID, assetInfo.fileId_);
325 value.PutString(PhotoColumn::PHOTO_DATE_DAY, assetInfo.dateDay_);
326 value.PutInt(PhotoColumn::MEDIA_IS_FAV, static_cast<int32_t>(assetInfo.isFavorite_));
327 value.PutInt(PhotoColumn::MEDIA_TYPE, assetInfo.mediaType_);
328 value.PutInt(PhotoColumn::MEDIA_HIDDEN, assetInfo.isHidden_);
329 value.PutLong(PhotoColumn::MEDIA_DATE_TRASHED, assetInfo.dateTrashedMs_);
330 value.PutInt(PhotoColumn::PHOTO_STRONG_ASSOCIATION, assetInfo.strongAssociation_);
331 value.PutInt(PhotoColumn::PHOTO_THUMBNAIL_VISIBLE, assetInfo.thumbnailVisible_);
332 value.PutLong(PhotoColumn::MEDIA_DATE_ADDED, assetInfo.dateAddedMs_);
333 value.PutLong(PhotoColumn::MEDIA_DATE_TAKEN, assetInfo.dateTakenMs_);
334 value.PutInt(PhotoColumn::PHOTO_SUBTYPE, assetInfo.subType_);
335 value.PutInt(PhotoColumn::PHOTO_SYNC_STATUS, assetInfo.syncStatus_);
336 value.PutInt(PhotoColumn::PHOTO_CLEAN_FLAG, assetInfo.cleanFlag_);
337 value.PutInt(PhotoColumn::MEDIA_TIME_PENDING, assetInfo.timePending_);
338 value.PutInt(PhotoColumn::PHOTO_IS_TEMP, assetInfo.isTemp_);
339 value.PutInt(PhotoColumn::PHOTO_BURST_COVER_LEVEL, assetInfo.burstCoverLevel_);
340 value.PutInt(PhotoColumn::PHOTO_OWNER_ALBUM_ID, assetInfo.ownerAlbumId_);
341 value.PutLong(PhotoColumn::PHOTO_HIDDEN_TIME, assetInfo.hiddenTime_);
342 value.PutString(PhotoColumn::MEDIA_NAME, assetInfo.displayName_);
343 value.PutString(PhotoColumn::MEDIA_FILE_PATH, assetInfo.path_);
344 return value;
345 }
346
GetAssetInfo(int32_t fileId=0)347 PhotoAssetChangeInfo GetAssetInfo(int32_t fileId = 0)
348 {
349 RdbPredicates queryPredicates(PhotoColumn::PHOTOS_TABLE);
350 queryPredicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
351
352 auto resultSet = g_rdbStore->QueryByStep(queryPredicates, PhotoAssetChangeInfo::GetPhotoAssetColumns());
353 EXPECT_TRUE(resultSet != nullptr);
354 auto assetInfos = PhotoAssetChangeInfo::GetInfoFromResult(resultSet, PhotoAssetChangeInfo::GetPhotoAssetColumns());
355 if (assetInfos.size() == 1) {
356 ACCURATE_DEBUG("assetInfo: %{public}s", assetInfos[0].ToString().c_str());
357 return assetInfos[0];
358 }
359 ACCURATE_DEBUG("asset info wrong: %{public}zu.", assetInfos.size());
360 return PhotoAssetChangeInfo();
361 }
362
CheckAssetEqual(const PhotoAssetChangeInfo & changeInfo1,const PhotoAssetChangeInfo & changeInfo2)363 bool CheckAssetEqual(const PhotoAssetChangeInfo &changeInfo1, const PhotoAssetChangeInfo &changeInfo2)
364 {
365 ACCURATE_DEBUG("%{public}s", changeInfo1.ToString().c_str());
366 ACCURATE_DEBUG("%{public}s", changeInfo2.ToString().c_str());
367 return changeInfo1.fileId_ == changeInfo2.fileId_;
368 }
369
CheckAssetChangeData(const PhotoAssetChangeData & changeData1,const PhotoAssetChangeData & changeData2)370 bool CheckAssetChangeData(const PhotoAssetChangeData &changeData1, const PhotoAssetChangeData &changeData2)
371 {
372 if (changeData1.isContentChanged_ != changeData2.isContentChanged_) {
373 MEDIA_ERR_LOG("isContentChanged_(%{public}d/%{public}d) wrong", changeData1.isContentChanged_,
374 changeData2.isContentChanged_);
375 return false;
376 }
377
378 if (changeData1.isDelete_ != changeData2.isDelete_) {
379 MEDIA_ERR_LOG("isDelete_(%{public}d/%{public}d) wrong", changeData1.isDelete_, changeData2.isDelete_);
380 return false;
381 }
382
383 if (changeData1.operation_ != changeData2.operation_) {
384 MEDIA_ERR_LOG("operation_(%{public}d/%{public}d) wrong", changeData1.operation_, changeData2.operation_);
385 return false;
386 }
387
388 if (changeData1.infoBeforeChange_.ownerAlbumId_ != changeData2.infoBeforeChange_.ownerAlbumId_) {
389 MEDIA_ERR_LOG("ownerAlbumId_(%{public}d/%{public}d) wrong", changeData1.infoBeforeChange_.ownerAlbumId_,
390 changeData2.infoBeforeChange_.ownerAlbumId_);
391 return false;
392 }
393
394 if (changeData1.infoAfterChange_.ownerAlbumId_ != changeData2.infoAfterChange_.ownerAlbumId_) {
395 MEDIA_ERR_LOG("ownerAlbumId_(%{public}d/%{public}d) wrong", changeData1.infoAfterChange_.ownerAlbumId_,
396 changeData2.infoAfterChange_.ownerAlbumId_);
397 return false;
398 }
399 return true;
400 }
401
CheckInsertAlbumInfo(const AlbumChangeInfo & refreshAlbumInfo,AlbumChangeInfo initAlbumInfo,const PhotoAssetChangeInfo & queryAssetInfo,map<int32_t,AlbumChangeData> & albumChangeDatas)402 bool CheckInsertAlbumInfo(const AlbumChangeInfo &refreshAlbumInfo, AlbumChangeInfo initAlbumInfo,
403 const PhotoAssetChangeInfo &queryAssetInfo, map<int32_t, AlbumChangeData> &albumChangeDatas)
404 {
405 // 数据信息
406 auto expectedAlbumInfo = initAlbumInfo;
407 if (!queryAssetInfo.isHidden_) {
408 // 普通资产数量更新
409 expectedAlbumInfo.count_++;
410 if (queryAssetInfo.mediaType_ == static_cast<int32_t>(MEDIA_TYPE_VIDEO)) {
411 expectedAlbumInfo.videoCount_++;
412 } else if (queryAssetInfo.mediaType_ == static_cast<int32_t>(MEDIA_TYPE_IMAGE)) {
413 expectedAlbumInfo.imageCount_++;
414 }
415 // 封面更新
416 // 视频和图片为date_added，其它为dateTaken
417 bool isDateAdded = initAlbumInfo.albumId_ == IMAGE_ALBUM_ID || initAlbumInfo.albumId_ == VIDEO_ALBUM_ID;
418 auto queryAssetCoverDateTime = isDateAdded ? queryAssetInfo.dateAddedMs_ : queryAssetInfo.dateTakenMs_;
419 if (queryAssetCoverDateTime > initAlbumInfo.coverDateTime_) {
420 expectedAlbumInfo.coverDateTime_ = queryAssetCoverDateTime;
421 expectedAlbumInfo.coverUri_ = queryAssetInfo.uri_;
422 if (!CheckAssetEqual(refreshAlbumInfo.coverInfo_, queryAssetInfo)) {
423 MEDIA_ERR_LOG("cover info wrong");
424 return false;
425 }
426 } else {
427 if (!CheckAssetEqual(refreshAlbumInfo.coverInfo_, initAlbumInfo.coverInfo_)) {
428 MEDIA_ERR_LOG("cover info wrong");
429 return false;
430 }
431 }
432 } else {
433 // 隐藏资产数量更新
434 expectedAlbumInfo.hiddenCount_++;
435 // 隐藏资产封面更新
436 if (queryAssetInfo.hiddenTime_ > initAlbumInfo.hiddenCoverDateTime_) {
437 expectedAlbumInfo.hiddenCoverDateTime_ = queryAssetInfo.hiddenTime_;
438 expectedAlbumInfo.hiddenCoverUri_ = queryAssetInfo.uri_;
439 if (!CheckAssetEqual(refreshAlbumInfo.hiddenCoverInfo_, queryAssetInfo)) {
440 MEDIA_ERR_LOG("hidden cover info wrong");
441 return false;
442 }
443 } else {
444 if (!CheckAssetEqual(refreshAlbumInfo.hiddenCoverInfo_, initAlbumInfo.hiddenCoverInfo_)) {
445 MEDIA_ERR_LOG("hidden cover info wrong");
446 return false;
447 }
448 }
449 }
450 if (!IsEqualAlbumInfo(refreshAlbumInfo, expectedAlbumInfo)) {
451 MEDIA_ERR_LOG("album info wrong");
452 return false;
453 }
454 AlbumChangeData albumChangeData;
455 albumChangeData.infoBeforeChange_ = initAlbumInfo;
456 albumChangeData.infoAfterChange_ = expectedAlbumInfo;
457 albumChangeData.isDelete_ = false;
458 albumChangeDatas.emplace(initAlbumInfo.albumId_, albumChangeData);
459
460 // 数据库信息
461 auto queryAlbumInfo = GetAlbumInfo(refreshAlbumInfo.albumId_, g_rdbStore);
462 if (!IsEqualAlbumInfo(refreshAlbumInfo, queryAlbumInfo)) {
463 MEDIA_ERR_LOG("database album info wrong");
464 return false;
465 }
466 return true;
467 }
468
CheckInsertHiddenAlbum(const AlbumChangeInfo & refreshHiddenAlbumInfo,AlbumChangeInfo initHiddenAlbumInfo,const PhotoAssetChangeInfo & queryAssetInfo,map<int32_t,AlbumChangeData> & albumChangeDatas)469 bool CheckInsertHiddenAlbum(const AlbumChangeInfo &refreshHiddenAlbumInfo, AlbumChangeInfo initHiddenAlbumInfo,
470 const PhotoAssetChangeInfo &queryAssetInfo, map<int32_t, AlbumChangeData> &albumChangeDatas)
471 {
472 AlbumChangeInfo expectedAlbumInfo = initHiddenAlbumInfo;
473 if (queryAssetInfo.isHidden_) {
474 // 隐藏相册更新
475 expectedAlbumInfo.count_++;
476 expectedAlbumInfo.hiddenCount_ = expectedAlbumInfo.count_;
477 if (queryAssetInfo.mediaType_ == static_cast<int32_t>(MEDIA_TYPE_VIDEO)) {
478 expectedAlbumInfo.videoCount_++;
479 } else {
480 expectedAlbumInfo.imageCount_++;
481 }
482 if (refreshHiddenAlbumInfo.hiddenCoverDateTime_ < queryAssetInfo.hiddenTime_) {
483 expectedAlbumInfo.hiddenCoverDateTime_ = queryAssetInfo.hiddenTime_;
484 expectedAlbumInfo.hiddenCoverUri_ = queryAssetInfo.uri_;
485 if (!CheckAssetEqual(refreshHiddenAlbumInfo.coverInfo_, queryAssetInfo)) {
486 MEDIA_ERR_LOG("hidden cover info not refresh");
487 return false;
488 }
489 } else {
490 if (!CheckAssetEqual(refreshHiddenAlbumInfo.coverInfo_, initHiddenAlbumInfo.coverInfo_)) {
491 MEDIA_ERR_LOG("hidden cover info wrong");
492 return false;
493 }
494 }
495 } else {
496 MEDIA_ERR_LOG("not hidden asset.");
497 return false;
498 }
499 if (!IsEqualAlbumInfo(refreshHiddenAlbumInfo, expectedAlbumInfo)) {
500 return false;
501 }
502 AlbumChangeData albumChangeData;
503 albumChangeData.infoBeforeChange_ = initHiddenAlbumInfo;
504 albumChangeData.infoAfterChange_ = expectedAlbumInfo;
505 albumChangeData.isDelete_ = false;
506 albumChangeDatas.emplace(initHiddenAlbumInfo.albumId_, albumChangeData);
507 return true;
508 }
509
CheckInsertAlbumInfos(const AssetAccurateRefresh & assetRefresh,const vector<AlbumChangeInfo> & initAlbumInfos,const PhotoAssetChangeInfo & queryAssetInfo,map<int32_t,AlbumChangeData> & albumChangeDatas)510 bool CheckInsertAlbumInfos(const AssetAccurateRefresh &assetRefresh, const vector<AlbumChangeInfo> &initAlbumInfos,
511 const PhotoAssetChangeInfo &queryAssetInfo, map<int32_t, AlbumChangeData> &albumChangeDatas)
512 {
513 // 刷新相册ID
514 EXPECT_TRUE(assetRefresh.albumRefreshExe_.forceRefreshAlbums_.empty());
515 auto forceRefreshHiddenAlbums = assetRefresh.albumRefreshExe_.forceRefreshHiddenAlbums_;
516 EXPECT_TRUE(forceRefreshHiddenAlbums.empty());
517
518 // 刷新信息和数据库信息
519 auto refreshAlbumsMap = assetRefresh.albumRefreshExe_.refreshAlbums_;
520 for (auto &albumInfo : initAlbumInfos) {
521 auto albumId = albumInfo.albumId_;
522 if (refreshAlbumsMap.find(albumId) == refreshAlbumsMap.end()) {
523 MEDIA_ERR_LOG("no album id, albumId:%{public}d", albumId);
524 return false;
525 }
526 auto albumInfoIter = refreshAlbumsMap.find(albumId);
527 if (albumInfoIter == refreshAlbumsMap.end()) {
528 MEDIA_ERR_LOG("no album info, albumId:%{public}d", albumId);
529 return false;
530 }
531 // 隐藏相册计算方式不同
532 if (albumId == HIDDEN_ALBUM_ID) {
533 if (!CheckInsertHiddenAlbum(albumInfoIter->second.second, albumInfo, queryAssetInfo, albumChangeDatas)) {
534 MEDIA_ERR_LOG("hidden album info wrong, albumId:%{public}d", albumId);
535 return false;
536 }
537 continue;
538 }
539 if (!CheckInsertAlbumInfo(albumInfoIter->second.second, albumInfo, queryAssetInfo, albumChangeDatas)) {
540 MEDIA_ERR_LOG("album info wrong, albumId:%{public}d", albumId);
541 return false;
542 }
543 ACCURATE_DEBUG("refrehInfo: %{public}s", albumInfoIter->second.second.ToString().c_str());
544 }
545 ACCURATE_DEBUG("return true");
546 return true;
547 }
548
CheckAlbumChangeDatas(const AlbumChangeData & notifyChangeData,const AlbumChangeData & expectedChangeData)549 bool CheckAlbumChangeDatas(const AlbumChangeData ¬ifyChangeData, const AlbumChangeData &expectedChangeData)
550 {
551 return CheckAlbumChangeData(notifyChangeData, expectedChangeData.operation_, expectedChangeData.infoBeforeChange_,
552 expectedChangeData.infoAfterChange_, expectedChangeData.isDelete_);
553 }
554
CheckInsertAssetNotifyInfo(pair<Notification::AssetRefreshOperation,vector<PhotoAssetChangeData>> notifyInfos,const PhotoAssetChangeData & assetChangeData,Notification::AssetRefreshOperation operation)555 bool CheckInsertAssetNotifyInfo(pair<Notification::AssetRefreshOperation, vector<PhotoAssetChangeData>> notifyInfos,
556 const PhotoAssetChangeData &assetChangeData, Notification::AssetRefreshOperation operation)
557 {
558 auto assetOperation = notifyInfos.first;
559 if (assetOperation != operation) {
560 MEDIA_ERR_LOG("notify asset operation wrong: %{public}d", assetOperation);
561 return false;
562 }
563 auto photoAssetChangeDataVec = notifyInfos.second;
564 if (photoAssetChangeDataVec.size() != 1) {
565 MEDIA_ERR_LOG("notify asset change info size wrong: %{public}zu", photoAssetChangeDataVec.size());
566 return false;
567 }
568 if (!CheckAssetChangeData(photoAssetChangeDataVec[0], assetChangeData)) {
569 MEDIA_ERR_LOG("asset change data wrong.");
570 return false;
571 }
572 return true;
573 }
574
CheckInsertNotifyAlbumInfos(map<Notification::AlbumRefreshOperation,vector<AlbumChangeData>> notifyAlbumInfos,Notification::AlbumRefreshOperation operation,const map<int32_t,AlbumChangeData> albumChangeDatas,int64_t notifySize)575 bool CheckInsertNotifyAlbumInfos(map<Notification::AlbumRefreshOperation, vector<AlbumChangeData>> notifyAlbumInfos,
576 Notification::AlbumRefreshOperation operation, const map<int32_t, AlbumChangeData> albumChangeDatas,
577 int64_t notifySize)
578 {
579 auto iter = notifyAlbumInfos.find(operation);
580 if (iter == notifyAlbumInfos.end()) {
581 MEDIA_ERR_LOG("notify album operation wrong: %{public}d", operation);
582 return false;
583 }
584
585 auto albumChangeDataVec = iter->second;
586 if (notifySize != albumChangeDataVec.size()) {
587 MEDIA_ERR_LOG("notify size wrong");
588 return false;
589 }
590 for (auto &albumChangeData : albumChangeDataVec) {
591 auto albumId = albumChangeData.infoAfterChange_.albumId_;
592 auto expectedAlbumChangeIter = albumChangeDatas.find(albumId);
593 if (expectedAlbumChangeIter == albumChangeDatas.end()) {
594 MEDIA_ERR_LOG("no albumId:%{public}d", albumId);
595 return false;
596 }
597 if (!CheckAlbumChangeDatas(albumChangeData, expectedAlbumChangeIter->second)) {
598 MEDIA_ERR_LOG("album change data wrong: %{public}d", albumId);
599 return false;
600 }
601 }
602 return true;
603 }
604
CheckInsertNotifyInfos(const AssetAccurateRefresh & assetRefresh,const PhotoAssetChangeData & assetChangeData,const map<int32_t,AlbumChangeData> albumChangeDatas)605 bool CheckInsertNotifyInfos(const AssetAccurateRefresh &assetRefresh, const PhotoAssetChangeData &assetChangeData,
606 const map<int32_t, AlbumChangeData> albumChangeDatas)
607 {
608 auto notifyAssetInfos = assetRefresh.notifyExe_.notifyInfos_;
609 if (notifyAssetInfos.size() != 1) {
610 MEDIA_ERR_LOG("notify asset change type size wrong: %{public}zu", notifyAssetInfos.size());
611 return false;
612 }
613 if (!CheckInsertAssetNotifyInfo(*(notifyAssetInfos.begin()), assetChangeData, Notification::ASSET_OPERATION_ADD)) {
614 MEDIA_ERR_LOG("asset notify info wrong.");
615 return false;
616 }
617
618 auto notifyAlbumInfos = assetRefresh.albumRefreshExe_.albumRefresh_.notifyExe_.notifyInfos_;
619 if (notifyAlbumInfos.size() != 1) {
620 MEDIA_ERR_LOG("notify album change type size wrong: %{public}zu", notifyAlbumInfos.size());
621 return false;
622 }
623 if (!CheckInsertNotifyAlbumInfos(notifyAlbumInfos, Notification::ALBUM_OPERATION_UPDATE, albumChangeDatas,
624 albumChangeDatas.size())) {
625 MEDIA_ERR_LOG("notify album info wrong.");
626 return false;
627 }
628
629 return true;
630 }
631
CheckAlbumInfo(const unordered_map<int32_t,pair<AlbumRefreshInfo,AlbumChangeInfo>> & refreshAlbums_,const AlbumChangeInfo & initAlbumInfo,const AlbumChangeInfo & expectedAlbumInfo,RdbOperation operation,map<int32_t,AlbumChangeData> & albumChangeDatas)632 bool CheckAlbumInfo(const unordered_map<int32_t, pair<AlbumRefreshInfo, AlbumChangeInfo>> &refreshAlbums_,
633 const AlbumChangeInfo &initAlbumInfo,
634 const AlbumChangeInfo &expectedAlbumInfo, RdbOperation operation, map<int32_t, AlbumChangeData> &albumChangeDatas)
635 {
636 auto refreshIter = refreshAlbums_.find(expectedAlbumInfo.albumId_);
637 if (refreshIter == refreshAlbums_.end()) {
638 MEDIA_ERR_LOG("No refresh album id: %{public}d", expectedAlbumInfo.albumId_);
639 return false;
640 }
641 if (!IsEqualAlbumInfo(expectedAlbumInfo, refreshIter->second.second)) {
642 MEDIA_ERR_LOG("refresh album info wrong");
643 return false;
644 }
645 AlbumChangeData albumChangeData;
646 albumChangeData.infoBeforeChange_ = initAlbumInfo;
647 albumChangeData.infoAfterChange_ = expectedAlbumInfo;
648 albumChangeData.operation_ = operation;
649 albumChangeData.isDelete_ = false;
650 albumChangeDatas.emplace(expectedAlbumInfo.albumId_, albumChangeData);
651 return true;
652 }
CheckAssetNotifyInfo(const map<Notification::AssetRefreshOperation,vector<PhotoAssetChangeData>> & notifyInfos,Notification::AssetRefreshOperation operation,const PhotoAssetChangeData & assetChangeData)653 bool CheckAssetNotifyInfo(const map<Notification::AssetRefreshOperation, vector<PhotoAssetChangeData>> ¬ifyInfos,
654 Notification::AssetRefreshOperation operation, const PhotoAssetChangeData &assetChangeData)
655 {
656 auto iter = notifyInfos.find(operation);
657 if (iter == notifyInfos.end()) {
658 MEDIA_ERR_LOG("no operation: %{public}d", operation);
659 return false;
660 }
661 auto assetChangeDatas = iter->second;
662 for (auto assetChangeData : assetChangeDatas) {
663 if (CheckAssetChangeData(assetChangeData, assetChangeData)) {
664 return true;
665 }
666 }
667 MEDIA_ERR_LOG("no equal asset change data.");
668 return false;
669 }
PrepareNormalAssets()670 void PrepareNormalAssets()
671 {
672 vector<ValuesBucket> values;
673 values.push_back(GetAssetInsertValue(GetFavoriteImageAsset()));
674 values.push_back(GetAssetInsertValue(GetFavoriteVideoAsset()));
675 values.push_back(GetAssetInsertValue(GetImageAsset()));
676 int64_t insertNums = 0;
677 auto ret = g_rdbStore->BatchInsert(insertNums, PhotoColumn::PHOTOS_TABLE, values);
678 ACCURATE_DEBUG("ret: %{public}d, insert values: %{public}" PRId64, ret, insertNums);
679 }
680
ModifyAssetDateTime(int64_t dateTaken)681 void ModifyAssetDateTime(int64_t dateTaken)
682 {
683 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
684 predicates.NotEqualTo(PhotoColumn::MEDIA_ID, 0);
685 ValuesBucket value;
686 value.PutInt(PhotoColumn::MEDIA_DATE_TAKEN, dateTaken);
687 value.PutInt(PhotoColumn::MEDIA_DATE_ADDED, dateTaken);
688 int32_t changedRows = 0;
689 auto ret = g_rdbStore->Update(changedRows, value, predicates);
690 ACCURATE_DEBUG("ret: %{public}d, insert values: %{public}d", ret, changedRows);
691 }
692
ClearAndRestart()693 void ClearAndRestart()
694 {
695 if (!MediaLibraryUnitTestUtils::IsValid()) {
696 MediaLibraryUnitTestUtils::Init();
697 }
698
699 system("rm -rf /storage/cloud/files/*");
700 system("rm -rf /storage/cloud/files/.thumbs");
701 system("rm -rf /storage/cloud/files/.editData");
702 system("rm -rf /storage/cloud/files/.cache");
703 for (const auto &dir : TEST_ROOT_DIRS) {
704 string ROOT_PATH = "/storage/cloud/100/files/";
705 bool ret = MediaFileUtils::CreateDirectory(ROOT_PATH + dir + "/");
706 CHECK_AND_PRINT_LOG(ret, "make %{public}s dir failed, ret=%{public}d", dir.c_str(), ret);
707 }
708 CleanTestTables();
709 SetTables();
710 }
711
712 } // namespace
713
SetUpTestCase()714 void AssetAccurateRefreshTest::SetUpTestCase()
715 {
716 MediaLibraryUnitTestUtils::Init();
717 g_rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
718 if (g_rdbStore == nullptr) {
719 MEDIA_ERR_LOG("Start MediaLibraryPhotoOperationsTest failed, can not get rdbstore");
720 exit(1);
721 }
722 SetTables();
723 }
724
SetUp()725 void AssetAccurateRefreshTest::SetUp()
726 {
727 ClearAndRestart();
728 PrepareAlbumData();
729 }
730
TearDownTestCase()731 void AssetAccurateRefreshTest::TearDownTestCase()
732 {
733 CleanTestTables();
734 g_rdbStore = nullptr;
735 MediaLibraryDataManager::GetInstance()->ClearMediaLibraryMgr();
736 this_thread::sleep_for(chrono::seconds(SLEEP_FIVE_SECONDS));
737 MEDIA_INFO_LOG("Clean is finish");
738 }
739
TearDown()740 void AssetAccurateRefreshTest::TearDown()
741 {
742 MEDIA_INFO_LOG("TearDown start");
743 RdbPredicates alumPredicates(PhotoAlbumColumns::TABLE);
744 alumPredicates.NotEqualTo(PhotoAlbumColumns::ALBUM_ID, to_string(0));
745
746 int deleteRows = 0;
747 g_rdbStore->Delete(deleteRows, alumPredicates);
748 MEDIA_INFO_LOG("delete album: %{public}d", deleteRows);
749
750 RdbPredicates photosPredicates(PhotoColumn::PHOTOS_TABLE);
751 photosPredicates.GreaterThan(PhotoColumn::MEDIA_ID, to_string(0));
752 g_rdbStore->Delete(deleteRows, photosPredicates);
753 MEDIA_INFO_LOG("delete Photos: %{public}d", deleteRows);
754 MEDIA_INFO_LOG("TearDown end");
755 }
756
757 HWTEST_F(AssetAccurateRefreshTest, Init_001, TestSize.Level2)
758 {
759 std::shared_ptr<TransactionOperations> trans = make_shared<TransactionOperations>("Init_001");
760 AssetAccurateRefresh assetRefresh(trans);
761 EXPECT_TRUE(assetRefresh.trans_ != nullptr);
762 EXPECT_TRUE(assetRefresh.dataManager_.trans_ != nullptr);
763 }
764
765 HWTEST_F(AssetAccurateRefreshTest, Insert_002, TestSize.Level2)
766 {
767 AssetAccurateRefresh assetRefresh("Insert_002");
768 int64_t outRowId = 0;
769 auto assetInfo = GetFavoriteVideoAsset();
770 auto value = GetAssetInsertValue(assetInfo);
771 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
772 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
773 EXPECT_TRUE(outRowId > 0);
774
775 // 数据库
776 auto queryAssetInfo = GetAssetInfo(assetInfo.fileId_);
777 EXPECT_TRUE(CheckAssetEqual(assetInfo, queryAssetInfo));
778
779 // data manager
780 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
781 PhotoAssetChangeData assetChangeData;
782 assetChangeData.operation_ = RDB_OPERATION_ADD;
783 assetChangeData.infoAfterChange_ = queryAssetInfo;
784 assetChangeData.isContentChanged_ = false;
785 assetChangeData.thumbnailChangeStatus_ = ThumbnailChangeStatus::THUMBNAIL_NOT_EXISTS;
786 assetChangeData.isDelete_ = false;
787 EXPECT_TRUE(changeDatasMap.size() == 1);
788 auto iter = changeDatasMap.begin();
789 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
790
791 // album 刷新
792 assetRefresh.RefreshAlbum();
793 // 相册刷新信息和数据库信息、通知信息
794 vector<AlbumChangeInfo> initAlbumInfos =
795 { FAVORITE_ALBUM_INFO, VIDEO_ALBUM_INFO, GetUserInsertInfo(FAVORITE_VIDEO_ASSET_ALBUM_ID)};
796 map<int32_t, AlbumChangeData> albumChangeDatas;
797 EXPECT_TRUE(CheckInsertAlbumInfos(assetRefresh, initAlbumInfos, queryAssetInfo, albumChangeDatas));
798
799 // Notify
800 assetRefresh.Notify();
801 EXPECT_TRUE(CheckInsertNotifyInfos(assetRefresh, assetChangeData, albumChangeDatas));
802 }
803
804 HWTEST_F(AssetAccurateRefreshTest, Insert_003, TestSize.Level2)
805 {
806 AssetAccurateRefresh assetRefresh("Insert_003");
807 int64_t outRowId = 0;
808 auto assetInfo = GetVideoAsset();
809 auto value = GetAssetInsertValue(assetInfo);
810 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
811 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
812 EXPECT_TRUE(outRowId > 1);
813 // 数据库
814 auto queryAssetInfo = GetAssetInfo(assetInfo.fileId_);
815 EXPECT_TRUE(CheckAssetEqual(assetInfo, queryAssetInfo));
816
817 // data manager
818 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
819 PhotoAssetChangeData assetChangeData;
820 assetChangeData.operation_ = RDB_OPERATION_ADD;
821 assetChangeData.infoAfterChange_ = queryAssetInfo;
822 EXPECT_TRUE(changeDatasMap.size() == 1);
823 auto iter = changeDatasMap.begin();
824 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
825
826 // album 刷新
827 assetRefresh.RefreshAlbum();
828 // 相册刷新信息和数据库信息、通知信息
829 vector<AlbumChangeInfo> initAlbumInfos = { VIDEO_ALBUM_INFO, GetUserInsertInfo(assetInfo.ownerAlbumId_)};
830 map<int32_t, AlbumChangeData> albumChangeDatas;
831 EXPECT_TRUE(CheckInsertAlbumInfos(assetRefresh, initAlbumInfos, queryAssetInfo, albumChangeDatas));
832
833 // Notify
834 assetRefresh.Notify();
835 EXPECT_TRUE(CheckInsertNotifyInfos(assetRefresh, assetChangeData, albumChangeDatas));
836 }
837
838 HWTEST_F(AssetAccurateRefreshTest, Insert_004, TestSize.Level2)
839 {
840 AssetAccurateRefresh assetRefresh("Insert_004");
841 int64_t outRowId = 0;
842 auto assetInfo = GetFavoriteImageAsset();
843 auto value = GetAssetInsertValue(assetInfo);
844 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
845 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
846 EXPECT_TRUE(outRowId > 1);
847 // 数据库
848 auto queryAssetInfo = GetAssetInfo(assetInfo.fileId_);
849 EXPECT_TRUE(CheckAssetEqual(assetInfo, queryAssetInfo));
850
851 // data manager
852 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
853 PhotoAssetChangeData assetChangeData;
854 assetChangeData.operation_ = RDB_OPERATION_ADD;
855 assetChangeData.infoAfterChange_ = queryAssetInfo;
856 EXPECT_TRUE(changeDatasMap.size() == 1);
857 auto iter = changeDatasMap.begin();
858 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
859
860 // album 刷新
861 assetRefresh.RefreshAlbum();
862 // 相册刷新信息和数据库信息、通知信息
863 vector<AlbumChangeInfo> initAlbumInfos =
864 { FAVORITE_ALBUM_INFO, IMAGE_ALBUM_INFO, GetUserInsertInfo(assetInfo.ownerAlbumId_)};
865 map<int32_t, AlbumChangeData> albumChangeDatas;
866 EXPECT_TRUE(CheckInsertAlbumInfos(assetRefresh, initAlbumInfos, queryAssetInfo, albumChangeDatas));
867
868 // Notify
869 assetRefresh.Notify();
870 EXPECT_TRUE(CheckInsertNotifyInfos(assetRefresh, assetChangeData, albumChangeDatas));
871 }
872
873 HWTEST_F(AssetAccurateRefreshTest, Insert_005, TestSize.Level2)
874 {
875 AssetAccurateRefresh assetRefresh("Insert_005");
876 int64_t outRowId = 0;
877 auto assetInfo = GetImageAsset();
878 auto value = GetAssetInsertValue(assetInfo);
879 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
880 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
881 EXPECT_TRUE(outRowId > 1);
882 // 数据库
883 auto queryAssetInfo = GetAssetInfo(assetInfo.fileId_);
884 EXPECT_TRUE(CheckAssetEqual(assetInfo, queryAssetInfo));
885
886 // data manager
887 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
888 PhotoAssetChangeData assetChangeData;
889 assetChangeData.operation_ = RDB_OPERATION_ADD;
890 assetChangeData.infoAfterChange_ = queryAssetInfo;
891 EXPECT_TRUE(changeDatasMap.size() == 1);
892 auto iter = changeDatasMap.begin();
893 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
894
895 // album 刷新
896 assetRefresh.RefreshAlbum();
897 // 相册刷新信息和数据库信息、通知信息
898 vector<AlbumChangeInfo> initAlbumInfos = { IMAGE_ALBUM_INFO, GetUserInsertInfo(assetInfo.ownerAlbumId_)};
899 map<int32_t, AlbumChangeData> albumChangeDatas;
900 EXPECT_TRUE(CheckInsertAlbumInfos(assetRefresh, initAlbumInfos, queryAssetInfo, albumChangeDatas));
901
902 // Notify
903 assetRefresh.Notify();
904 EXPECT_TRUE(CheckInsertNotifyInfos(assetRefresh, assetChangeData, albumChangeDatas));
905 }
906
907 HWTEST_F(AssetAccurateRefreshTest, Insert_006, TestSize.Level2)
908 {
909 AssetAccurateRefresh assetRefresh("Insert_006");
910 int64_t outRowId = 0;
911 auto assetInfo = GetFavoriteVideoHiddenAsset();
912 auto value = GetAssetInsertValue(assetInfo);
913 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
914 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
915 EXPECT_TRUE(outRowId > 1);
916 // 资产数据库
917 auto queryAssetInfo = GetAssetInfo(assetInfo.fileId_);
918 EXPECT_TRUE(CheckAssetEqual(assetInfo, queryAssetInfo));
919
920 // 资产data manager信息
921 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
922 PhotoAssetChangeData assetChangeData;
923 assetChangeData.operation_ = RDB_OPERATION_ADD;
924 assetChangeData.infoAfterChange_ = queryAssetInfo;
925 EXPECT_TRUE(changeDatasMap.size() == 1);
926 auto iter = changeDatasMap.begin();
927 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
928
929 // album 刷新
930 assetRefresh.RefreshAlbum();
931 // 相册刷新信息和数据库信息、通知信息
932 vector<AlbumChangeInfo> initAlbumInfos =
933 { FAVORITE_ALBUM_INFO, VIDEO_ALBUM_INFO, HIDDEN_ALBUM_INFO, GetUserInsertInfo(assetInfo.ownerAlbumId_)};
934 map<int32_t, AlbumChangeData> albumChangeDatas;
935 EXPECT_TRUE(CheckInsertAlbumInfos(assetRefresh, initAlbumInfos, queryAssetInfo, albumChangeDatas));
936
937 // Notify
938 assetRefresh.Notify();
939 // 资产通知
940 auto notifyAssetInfos = assetRefresh.notifyExe_.notifyInfos_;
941 EXPECT_TRUE(notifyAssetInfos.size() == 1);
942 EXPECT_TRUE(CheckInsertAssetNotifyInfo(*(notifyAssetInfos.begin()), assetChangeData,
943 Notification::ASSET_OPERATION_ADD_HIDDEN));
944
945 auto notifyAlbumInfos = assetRefresh.albumRefreshExe_.albumRefresh_.notifyExe_.notifyInfos_;
946 EXPECT_TRUE(notifyAlbumInfos.size() == 1);
947 EXPECT_TRUE(CheckInsertNotifyAlbumInfos(notifyAlbumInfos, Notification::ALBUM_OPERATION_UPDATE_HIDDEN,
948 albumChangeDatas, 4));
949 }
950
951 HWTEST_F(AssetAccurateRefreshTest, Insert_007, TestSize.Level2)
952 {
953 AssetAccurateRefresh assetRefresh("Insert_007");
954 int64_t outRowId = 0;
955 auto assetInfo = GetCloudAsset();
956 auto value = GetAssetInsertValue(assetInfo);
957 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
958 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
959 EXPECT_TRUE(outRowId > 1);
960 // 数据库
961 auto queryAssetInfo = GetAssetInfo(assetInfo.fileId_);
962 EXPECT_TRUE(CheckAssetEqual(assetInfo, queryAssetInfo));
963
964 // data manager
965 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
966 PhotoAssetChangeData assetChangeData;
967 assetChangeData.operation_ = RDB_OPERATION_ADD;
968 assetChangeData.infoAfterChange_ = queryAssetInfo;
969 EXPECT_TRUE(changeDatasMap.size() == 1);
970 auto iter = changeDatasMap.begin();
971 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
972
973 // album 刷新
974 assetRefresh.RefreshAlbum();
975 // 相册刷新信息和数据库信息、通知信息
976 vector<AlbumChangeInfo> initAlbumInfos =
977 { IMAGE_ALBUM_INFO, CLOUD_ENHANCEMENT_ALBUM_INFO, GetUserInsertInfo(assetInfo.ownerAlbumId_)};
978 map<int32_t, AlbumChangeData> albumChangeDatas;
979 EXPECT_TRUE(CheckInsertAlbumInfos(assetRefresh, initAlbumInfos, queryAssetInfo, albumChangeDatas));
980
981 // Notify
982 assetRefresh.Notify();
983 // 资产通知
984 auto notifyAssetInfos = assetRefresh.notifyExe_.notifyInfos_;
985 EXPECT_TRUE(notifyAssetInfos.size() == 1);
986 EXPECT_TRUE(CheckInsertAssetNotifyInfo(*(notifyAssetInfos.begin()), assetChangeData,
987 Notification::ASSET_OPERATION_ADD));
988
989 auto notifyAlbumInfos = assetRefresh.albumRefreshExe_.albumRefresh_.notifyExe_.notifyInfos_;
990 EXPECT_TRUE(notifyAlbumInfos.size() == 1);
991 EXPECT_TRUE(
992 CheckInsertNotifyAlbumInfos(notifyAlbumInfos, Notification::ALBUM_OPERATION_UPDATE, albumChangeDatas, 3));
993 }
994
995 HWTEST_F(AssetAccurateRefreshTest, Insert_008, TestSize.Level2)
996 {
997 AssetAccurateRefresh assetRefresh("Insert_008");
998 int64_t outRowId = 0;
999 auto assetInfo = GetTrashAsset();
1000 auto value = GetAssetInsertValue(assetInfo);
1001 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
1002 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1003 EXPECT_TRUE(outRowId > 1);
1004 // 数据库
1005 auto queryAssetInfo = GetAssetInfo(assetInfo.fileId_);
1006 EXPECT_TRUE(CheckAssetEqual(assetInfo, queryAssetInfo));
1007
1008 // data manager
1009 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
1010 PhotoAssetChangeData assetChangeData;
1011 assetChangeData.operation_ = RDB_OPERATION_ADD;
1012 assetChangeData.infoAfterChange_ = queryAssetInfo;
1013 EXPECT_TRUE(changeDatasMap.size() == 1);
1014 auto iter = changeDatasMap.begin();
1015 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
1016
1017 // album 刷新
1018 assetRefresh.RefreshAlbum();
1019 // 相册刷新信息和数据库信息、通知信息
1020 vector<AlbumChangeInfo> initAlbumInfos = { TRASH_ALBUM_INFO };
1021 map<int32_t, AlbumChangeData> albumChangeDatas;
1022 EXPECT_TRUE(CheckInsertAlbumInfos(assetRefresh, initAlbumInfos, queryAssetInfo, albumChangeDatas));
1023
1024 // Notify
1025 assetRefresh.Notify();
1026 // 资产通知
1027 auto notifyAssetInfos = assetRefresh.notifyExe_.notifyInfos_;
1028 EXPECT_TRUE(notifyAssetInfos.size() == 1);
1029 EXPECT_TRUE(CheckInsertAssetNotifyInfo(*(notifyAssetInfos.begin()), assetChangeData,
1030 Notification::ASSET_OPERATION_ADD_TRASH));
1031
1032 auto notifyAlbumInfos = assetRefresh.albumRefreshExe_.albumRefresh_.notifyExe_.notifyInfos_;
1033 EXPECT_TRUE(notifyAlbumInfos.size() == 1);
1034 EXPECT_TRUE(CheckInsertNotifyAlbumInfos(notifyAlbumInfos, Notification::ALBUM_OPERATION_UPDATE_TRASH,
1035 albumChangeDatas, 1));
1036 }
1037
1038 // trash 非封面
1039 HWTEST_F(AssetAccurateRefreshTest, Update_009, TestSize.Level2)
1040 {
1041 PrepareNormalAssets();
1042 // 修改1个
1043 ModifyAssetDateTime(12345); // dateTaken时间小于所有的相册coverDateTime
1044
1045 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1046 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1047 ValuesBucket value;
1048 int64_t dataTrashTime = 1000000;
1049 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1050 AssetAccurateRefresh assetRefresh("Update_009");
1051 int32_t changedRow = 0;
1052 auto ret = assetRefresh.Update(changedRow, value, predicates);
1053 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1054 EXPECT_TRUE(changedRow == 1);
1055 // 数据库
1056 auto queryAssetInfo = GetAssetInfo(FAVORITE_IMAGE_ASSET_FILE_ID);
1057 EXPECT_TRUE(queryAssetInfo.dateTrashedMs_ == dataTrashTime);
1058
1059 // data manager
1060 auto changeDatasMap = assetRefresh.dataManager_.changeDatas_;
1061 PhotoAssetChangeData assetChangeData;
1062 assetChangeData.operation_ = RDB_OPERATION_UPDATE;
1063 assetChangeData.infoBeforeChange_ = GetFavoriteImageAsset();
1064 assetChangeData.infoAfterChange_ = queryAssetInfo;
1065 EXPECT_TRUE(changeDatasMap.size() == 1);
1066 auto iter = changeDatasMap.begin();
1067 EXPECT_TRUE(CheckAssetChangeData(iter->second, assetChangeData));
1068
1069 // album 刷新
1070 assetRefresh.RefreshAlbum();
1071 // 相册刷新信息和数据库信息、通知信息
1072 vector<AlbumChangeInfo> initAlbumInfos = { FAVORITE_ALBUM_INFO, IMAGE_ALBUM_INFO, TRASH_ALBUM_INFO,
1073 GetUserInsertInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID)};
1074 map<int32_t, AlbumChangeData> albumChangeDatas;
1075
1076 // 刷新信息和数据库信息
1077 auto refreshAlbumsMap = assetRefresh.albumRefreshExe_.refreshAlbums_;
1078 AlbumChangeInfo refreshAlbumInfo = FAVORITE_ALBUM_INFO;
1079 refreshAlbumInfo.count_--;
1080 refreshAlbumInfo.imageCount_--;
1081 CheckAlbumInfo(refreshAlbumsMap, FAVORITE_ALBUM_INFO, refreshAlbumInfo, RDB_OPERATION_UPDATE, albumChangeDatas);
1082
1083 refreshAlbumInfo = IMAGE_ALBUM_INFO;
1084 refreshAlbumInfo.count_--;
1085 refreshAlbumInfo.imageCount_--;
1086 CheckAlbumInfo(refreshAlbumsMap, IMAGE_ALBUM_INFO, refreshAlbumInfo, RDB_OPERATION_UPDATE, albumChangeDatas);
1087
1088 refreshAlbumInfo = GetUserInsertInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID);
1089 refreshAlbumInfo.count_--;
1090 refreshAlbumInfo.imageCount_--;
1091 CheckAlbumInfo(refreshAlbumsMap, GetUserInsertInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID), refreshAlbumInfo,
1092 RDB_OPERATION_UPDATE, albumChangeDatas);
1093 // trash不更新封面
1094 refreshAlbumInfo = TRASH_ALBUM_INFO;
1095 refreshAlbumInfo.count_++;
1096 refreshAlbumInfo.imageCount_++;
1097 CheckAlbumInfo(refreshAlbumsMap, TRASH_ALBUM_INFO, refreshAlbumInfo, RDB_OPERATION_UPDATE, albumChangeDatas);
1098
1099 // Notify
1100 assetRefresh.Notify();
1101 // 资产通知
1102 auto notifyAssetInfos = assetRefresh.notifyExe_.notifyInfos_;
1103 EXPECT_TRUE(notifyAssetInfos.size() == 2);
1104 CheckAssetNotifyInfo(notifyAssetInfos, Notification::ASSET_OPERATION_UPDATE_ADD_TRASH, assetChangeData);
1105 CheckAssetNotifyInfo(notifyAssetInfos, Notification::ASSET_OPERATION_UPDATE_REMOVE_NORMAL, assetChangeData);
1106
1107 auto notifyAlbumInfos = assetRefresh.albumRefreshExe_.albumRefresh_.notifyExe_.notifyInfos_;
1108 EXPECT_TRUE(notifyAlbumInfos.size() == 2);
1109 EXPECT_TRUE(
1110 CheckInsertNotifyAlbumInfos(notifyAlbumInfos, Notification::ALBUM_OPERATION_UPDATE_TRASH, albumChangeDatas, 1));
1111 EXPECT_TRUE(
1112 CheckInsertNotifyAlbumInfos(notifyAlbumInfos, Notification::ALBUM_OPERATION_UPDATE, albumChangeDatas, 3));
1113 }
1114
1115 HWTEST_F(AssetAccurateRefreshTest, Update_Exceed_010, TestSize.Level2)
1116 {
1117 PrepareNormalAssets();
1118 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1119 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1120 ValuesBucket value;
1121 int64_t dataTrashTime = 1000000;
1122 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1123 AssetAccurateRefresh assetRefresh("Update_Exceed_010");
1124 int32_t changedRow = 0;
1125 auto ret = assetRefresh.Update(changedRow, value, predicates);
1126 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1127 EXPECT_TRUE(changedRow == 1);
1128
1129 // 修改changeDatas_的数量
1130 auto &changeDatasMap = assetRefresh.dataManager_.changeDatas_;
1131 PhotoAssetChangeData changeData;
1132 // 总共1000条
1133 for (int i = 0; i < 999; ++i) {
1134 changeDatasMap.insert_or_assign(1000000 + i, changeData);
1135 }
1136 ValuesBucket newValue;
1137 newValue.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, 0);
1138 ret = assetRefresh.Update(changedRow, newValue, predicates);
1139 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1140 EXPECT_TRUE(changedRow == 1);
1141 // 总共1000条
1142 EXPECT_TRUE(assetRefresh.dataManager_.CheckIsExceed());
1143 EXPECT_TRUE(assetRefresh.dataManager_.changeDatas_.empty());
1144 EXPECT_TRUE(assetRefresh.RefreshAlbum() == ACCURATE_REFRESH_RET_OK);
1145 EXPECT_TRUE(assetRefresh.Notify() == ACCURATE_REFRESH_RET_OK);
1146 }
1147
1148 HWTEST_F(AssetAccurateRefreshTest, Update_Exceed_011, TestSize.Level2)
1149 {
1150 PrepareNormalAssets();
1151 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1152 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1153 ValuesBucket value;
1154 int64_t dataTrashTime = 1000000;
1155 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1156 AssetAccurateRefresh assetRefresh;
1157 int32_t changedRow = 0;
1158 auto ret = assetRefresh.Update(changedRow, value, predicates);
1159 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1160 EXPECT_TRUE(changedRow == 1);
1161
1162 // 修改changeDatas_的数量
1163 auto &changeDatasMap = assetRefresh.dataManager_.changeDatas_;
1164 PhotoAssetChangeData changeData;
1165 // 总共999条
1166 for (int i = 0; i < 998; ++i) {
1167 changeDatasMap.insert_or_assign(1000000 + i, changeData);
1168 }
1169 ValuesBucket newValue;
1170 newValue.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, 0);
1171 ret = assetRefresh.Update(changedRow, newValue, predicates);
1172 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1173 EXPECT_TRUE(changedRow == 1);
1174 EXPECT_TRUE(!assetRefresh.dataManager_.CheckIsExceed());
1175 // 总共999条
1176 EXPECT_TRUE(assetRefresh.dataManager_.changeDatas_.size() == 999);
1177 }
1178
1179 HWTEST_F(AssetAccurateRefreshTest, Update_MultiThread_012, TestSize.Level2)
1180 {
1181 PrepareNormalAssets();
1182
__anoncc1e30ad0202() 1183 std::thread taskTrash([]() {
1184 ACCURATE_DEBUG("taskTrash start");
1185 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1186 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1187 ValuesBucket value;
1188 int64_t dataTrashTime = 1000000;
1189 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1190 AssetAccurateRefresh assetRefresh("Update_MultiThread_012");
1191 int32_t changedRow = 0;
1192 auto ret = assetRefresh.Update(changedRow, value, predicates);
1193 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1194 EXPECT_TRUE(changedRow == 1);
1195 std::this_thread::sleep_for(chrono::milliseconds(300));
1196 // album 刷新
1197 assetRefresh.RefreshAlbum();
1198 ACCURATE_DEBUG("taskTrash end");
1199 assetRefresh.Notify();
1200 });
1201
__anoncc1e30ad0302() 1202 std::thread taskFavorite([]() {
1203 ACCURATE_DEBUG("taskFavorite start");
1204 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1205 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1206 ValuesBucket value;
1207 value.PutInt(PhotoColumn::MEDIA_IS_FAV, 0);
1208 AssetAccurateRefresh assetRefresh("Update_MultiThread_012");
1209 int32_t changedRow = 0;
1210 auto ret = assetRefresh.Update(changedRow, value, predicates);
1211 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1212 EXPECT_TRUE(changedRow == 1);
1213 // album 刷新
1214 std::this_thread::sleep_for(chrono::milliseconds(100));
1215 assetRefresh.RefreshAlbum();
1216 ACCURATE_DEBUG("taskFavorite end");
1217 assetRefresh.Notify();
1218 });
1219 taskTrash.join();
1220 taskFavorite.join();
1221
1222 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1223 auto trashAlbumInfo = AccurateRefresh::GetAlbumInfo(TRASH_ALBUM_ID, g_rdbStore);
1224 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1225 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1226 EXPECT_TRUE(favoriteAlbumInfo.count_ == FAVORITE_ALBUM_COUNT - 1);
1227 EXPECT_TRUE(trashAlbumInfo.count_ == TRASH_ALBUM_COUNT + 1);
1228 EXPECT_TRUE(imageAlbumInfo.count_ == IMAGE_ALBUM_COUNT - 1);
1229 EXPECT_TRUE(ownerAlbumInfo.count_ == USER_ALBUM_COUNT - 1);
1230 }
1231
InsertAndUpdateMultiThread(int32_t delayTime)1232 void InsertAndUpdateMultiThread(int32_t delayTime)
1233 {
1234 {
1235 RdbPredicates predicates(PhotoAlbumColumns::TABLE);
1236 vector<string> albumIds = {
1237 to_string(FAVORITE_ALBUM_ID),
1238 to_string(IMAGE_ALBUM_ID),
1239 to_string(FAVORITE_IMAGE_ASSET_ALBUM_ID)
1240 };
1241 predicates.In(PhotoAlbumColumns::ALBUM_ID, albumIds);
1242 ValuesBucket value;
1243 value.PutInt(PhotoAlbumColumns::ALBUM_COUNT, 0);
1244 int32_t changedRows = 0;
1245 auto ret = g_rdbStore->Update(changedRows, value, predicates);
1246 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1247 }
1248
1249 bool isRefreshAllInsert = false;
1250 std::thread taskInsert([&]() {
1251 AssetAccurateRefresh assetRefresh("InsertAndUpdateMultiThread");
1252 int64_t outRowId = 0;
1253 auto assetInfo = GetFavoriteImageAsset();
1254 auto value = GetAssetInsertValue(assetInfo);
1255 auto ret = assetRefresh.Insert(outRowId, PhotoColumn::PHOTOS_TABLE, value);
1256 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1257 isRefreshAllInsert = assetRefresh.dataManager_.isForRecheck_;
1258 if (isRefreshAllInsert) {
1259 std::this_thread::sleep_for(chrono::milliseconds(200));
1260 }
1261 // album 刷新
1262 assetRefresh.RefreshAlbum();
1263 // Notify
1264 assetRefresh.Notify();
1265 });
1266
1267 int changedRow = 0;
1268 bool isRefreshAllUpdate = false;
1269 std::thread taskUpdate([&]() {
1270 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1271 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1272 ValuesBucket value;
1273 value.PutInt(PhotoColumn::MEDIA_IS_FAV, 0);
1274 AssetAccurateRefresh assetRefresh("InsertAndUpdateMultiThread");
1275 std::this_thread::sleep_for(chrono::milliseconds(delayTime));
1276 auto ret = assetRefresh.Update(changedRow, value, predicates);
1277 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1278 isRefreshAllUpdate = assetRefresh.dataManager_.isForRecheck_;
1279 // refresh all时，放在最后处理，才能获取准确的结果
1280 if (isRefreshAllUpdate) {
1281 std::this_thread::sleep_for(chrono::milliseconds(200));
1282 }
1283 // album 刷新
1284 assetRefresh.RefreshAlbum();
1285 // Notify
1286 assetRefresh.Notify();
1287 });
1288 taskInsert.join();
1289 taskUpdate.join();
1290 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1291 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1292 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1293
1294 // refresh all时，会把数据都刷成0
1295 if (isRefreshAllInsert || isRefreshAllUpdate) {
1296 EXPECT_TRUE(favoriteAlbumInfo.count_ == 0);
1297 EXPECT_TRUE(imageAlbumInfo.count_ == 0);
1298 EXPECT_TRUE(ownerAlbumInfo.count_ == 0);
1299 ACCURATE_DEBUG("refresh all");
1300 return;
1301 }
1302
1303 if (changedRow == 1) {
1304 EXPECT_TRUE(imageAlbumInfo.count_ == 1);
1305 EXPECT_TRUE(ownerAlbumInfo.count_ == 1);
1306 ACCURATE_DEBUG("update");
1307 } else {
1308 EXPECT_TRUE(favoriteAlbumInfo.count_ == 1);
1309 EXPECT_TRUE(imageAlbumInfo.count_ == 1);
1310 EXPECT_TRUE(ownerAlbumInfo.count_ == 1);
1311 ACCURATE_DEBUG("no update");
1312 }
1313 }
1314
1315 HWTEST_F(AssetAccurateRefreshTest, Insert_MultiThread_013, TestSize.Level2)
1316 {
1317 InsertAndUpdateMultiThread(0);
1318 }
1319
1320 HWTEST_F(AssetAccurateRefreshTest, Insert_MultiThread_014, TestSize.Level2)
1321 {
1322 InsertAndUpdateMultiThread(5);
1323 }
1324
1325 HWTEST_F(AssetAccurateRefreshTest, Insert_MultiThread_015, TestSize.Level2)
1326 {
1327 InsertAndUpdateMultiThread(10);
1328 }
1329
1330 HWTEST_F(AssetAccurateRefreshTest, Insert_MultiThread_016, TestSize.Level2)
1331 {
1332 InsertAndUpdateMultiThread(15);
1333 }
1334
1335 HWTEST_F(AssetAccurateRefreshTest, Update_MultiThread_017, TestSize.Level2)
1336 {
1337 PrepareNormalAssets();
1338
__anoncc1e30ad0602() 1339 std::thread taskTrash([]() {
1340 ACCURATE_DEBUG("taskTrash start");
1341 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1342 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1343 ValuesBucket value;
1344 int64_t dataTrashTime = 1000000;
1345 value.PutLong(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1346 AssetAccurateRefresh assetRefresh("Update_MultiThread_017");
1347 int32_t changedRow = 0;
1348 auto ret = assetRefresh.Update(changedRow, value, predicates);
1349 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1350 EXPECT_TRUE(changedRow == 1);
1351
1352 ValuesBucket value2;
1353 value2.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, 0);
1354 ret = assetRefresh.Update(changedRow, value2, predicates);
1355 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1356 EXPECT_TRUE(changedRow == 1);
1357
1358 std::this_thread::sleep_for(chrono::milliseconds(300));
1359 // album 刷新
1360 assetRefresh.RefreshAlbum();
1361 ACCURATE_DEBUG("taskTrash end");
1362 assetRefresh.Notify();
1363 });
1364
__anoncc1e30ad0702() 1365 std::thread taskFavorite([]() {
1366 ACCURATE_DEBUG("taskFavorite start");
1367 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1368 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1369 ValuesBucket value;
1370 value.PutInt(PhotoColumn::MEDIA_IS_FAV, 0);
1371 AssetAccurateRefresh assetRefresh("Update_MultiThread_017");
1372 int32_t changedRow = 0;
1373 auto ret = assetRefresh.Update(changedRow, value, predicates);
1374 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1375 EXPECT_TRUE(changedRow == 1);
1376 // album 刷新
1377 std::this_thread::sleep_for(chrono::milliseconds(100));
1378 assetRefresh.RefreshAlbum();
1379 ACCURATE_DEBUG("taskFavorite end");
1380 assetRefresh.Notify();
1381 });
1382 taskTrash.join();
1383 taskFavorite.join();
1384
1385 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1386 auto trashAlbumInfo = AccurateRefresh::GetAlbumInfo(TRASH_ALBUM_ID, g_rdbStore);
1387 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1388 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1389 EXPECT_TRUE(favoriteAlbumInfo.count_ == FAVORITE_ALBUM_COUNT - 1);
1390 EXPECT_TRUE(trashAlbumInfo.count_ == TRASH_ALBUM_COUNT);
1391 EXPECT_TRUE(imageAlbumInfo.count_ == IMAGE_ALBUM_COUNT);
1392 EXPECT_TRUE(ownerAlbumInfo.count_ == USER_ALBUM_COUNT);
1393 }
1394
1395 HWTEST_F(AssetAccurateRefreshTest, MultiThread_Clear_018, TestSize.Level2)
1396 {
1397 PrepareNormalAssets();
__anoncc1e30ad0802() 1398 std::thread taskTrash([]() {
1399 ACCURATE_DEBUG("taskTrash start");
1400 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1401 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1402 ValuesBucket value;
1403 int64_t dataTrashTime = 1000000;
1404 value.PutLong(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1405 AssetAccurateRefresh assetRefresh("MultiThread_Clear_018");
1406 int32_t changedRow = 0;
1407 auto ret = assetRefresh.Update(changedRow, value, predicates);
1408 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1409 EXPECT_TRUE(changedRow == 1);
1410
1411 ValuesBucket value2;
1412 value2.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, 0);
1413 ret = assetRefresh.Update(changedRow, value2, predicates);
1414 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1415 EXPECT_TRUE(changedRow == 1);
1416 auto infos = MultiThreadAssetChangeInfoMgr::GetInstance().GetAssetChangeData(FAVORITE_IMAGE_ASSET_FILE_ID);
1417 EXPECT_TRUE(infos.first.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1418 EXPECT_TRUE(infos.second.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1419 auto multiAssetMap = MultiThreadAssetChangeInfoMgr::GetInstance().assetChangeDataMap_;
1420 auto iter = multiAssetMap.find(FAVORITE_IMAGE_ASSET_FILE_ID);
1421 EXPECT_TRUE(iter != multiAssetMap.end());
1422 auto data = iter->second;
1423 EXPECT_TRUE(data.count_ >= 2);
1424 EXPECT_TRUE(data.isMultiOperation_);
1425 ACCURATE_DEBUG("count[%{public}d]", data.count_);
1426 std::this_thread::sleep_for(chrono::milliseconds(100));
1427 });
1428
__anoncc1e30ad0902() 1429 std::thread taskTrash2([]() {
1430 ACCURATE_DEBUG("taskTrash start");
1431 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1432 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1433 ValuesBucket value;
1434 int64_t dataTrashTime = 1000000;
1435 value.PutLong(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1436 AssetAccurateRefresh assetRefresh("MultiThread_Clear_018");
1437 int32_t changedRow = 0;
1438 auto ret = assetRefresh.Update(changedRow, value, predicates);
1439 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1440 EXPECT_TRUE(changedRow == 1);
1441
1442 ValuesBucket value2;
1443 value2.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, 0);
1444 ret = assetRefresh.Update(changedRow, value2, predicates);
1445 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1446 EXPECT_TRUE(changedRow == 1);
1447 auto infos = MultiThreadAssetChangeInfoMgr::GetInstance().GetAssetChangeData(FAVORITE_IMAGE_ASSET_FILE_ID);
1448 EXPECT_TRUE(infos.first.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1449 EXPECT_TRUE(infos.second.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1450 auto multiAssetMap = MultiThreadAssetChangeInfoMgr::GetInstance().assetChangeDataMap_;
1451 auto iter = multiAssetMap.find(FAVORITE_IMAGE_ASSET_FILE_ID);
1452 EXPECT_TRUE(iter != multiAssetMap.end());
1453 auto data = iter->second;
1454 EXPECT_TRUE(data.count_ >= 2);
1455 EXPECT_TRUE(data.isMultiOperation_);
1456 ACCURATE_DEBUG("count[%{public}d]", data.count_);
1457 std::this_thread::sleep_for(chrono::milliseconds(100));
1458 });
1459
1460 taskTrash.join();
1461 taskTrash2.join();
1462 auto infos = MultiThreadAssetChangeInfoMgr::GetInstance().GetAssetChangeData(FAVORITE_IMAGE_ASSET_FILE_ID);
1463 EXPECT_TRUE(infos.first.fileId_ == INVALID_INT32_VALUE);
1464 EXPECT_TRUE(infos.second.fileId_ == INVALID_INT32_VALUE);
1465 }
1466
1467 HWTEST_F(AssetAccurateRefreshTest, MultiThread_Clear_019, TestSize.Level2)
1468 {
1469 PrepareNormalAssets();
__anoncc1e30ad0a02() 1470 std::thread taskTrash([]() {
1471 ACCURATE_DEBUG("taskTrash start");
1472 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1473 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1474 ValuesBucket value;
1475 int64_t dataTrashTime = 1000000;
1476 value.PutLong(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1477 shared_ptr<AssetAccurateRefresh> assetRefresh = make_shared<AssetAccurateRefresh>("MultiThread_Clear_019");
1478 int32_t changedRow = 0;
1479 auto ret = assetRefresh->Update(changedRow, value, predicates);
1480 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1481 EXPECT_TRUE(changedRow == 1);
1482
1483 ValuesBucket value2;
1484 value2.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, 0);
1485 ret = assetRefresh->Update(changedRow, value2, predicates);
1486 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1487 EXPECT_TRUE(changedRow == 1);
1488 auto infos = MultiThreadAssetChangeInfoMgr::GetInstance().GetAssetChangeData(FAVORITE_IMAGE_ASSET_FILE_ID);
1489 EXPECT_TRUE(infos.first.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1490 EXPECT_TRUE(infos.second.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1491 auto multiAssetMap = MultiThreadAssetChangeInfoMgr::GetInstance().assetChangeDataMap_;
1492 auto iter = multiAssetMap.find(FAVORITE_IMAGE_ASSET_FILE_ID);
1493 EXPECT_TRUE(iter != multiAssetMap.end());
1494 auto data = iter->second;
1495 EXPECT_TRUE(data.count_ >= 2);
1496 EXPECT_TRUE(data.isMultiOperation_);
1497 ACCURATE_DEBUG("count[%{public}d]", data.count_);
1498 std::this_thread::sleep_for(chrono::milliseconds(100));
1499 });
1500
__anoncc1e30ad0b02() 1501 std::thread taskTrash2([]() {
1502 ACCURATE_DEBUG("taskTrash start");
1503 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1504 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1505 ValuesBucket value;
1506 int64_t dataTrashTime = 1000000;
1507 value.PutLong(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1508 shared_ptr<AssetAccurateRefresh> assetRefresh = make_shared<AssetAccurateRefresh>("MultiThread_Clear_019");
1509 int32_t changedRow = 0;
1510 auto ret = assetRefresh->Update(changedRow, value, predicates);
1511 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1512 EXPECT_TRUE(changedRow == 1);
1513
1514 ValuesBucket value2;
1515 value2.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, 0);
1516 ret = assetRefresh->Update(changedRow, value2, predicates);
1517 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1518 EXPECT_TRUE(changedRow == 1);
1519 auto infos = MultiThreadAssetChangeInfoMgr::GetInstance().GetAssetChangeData(FAVORITE_IMAGE_ASSET_FILE_ID);
1520 EXPECT_TRUE(infos.first.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1521 EXPECT_TRUE(infos.second.fileId_ == FAVORITE_IMAGE_ASSET_FILE_ID);
1522 auto multiAssetMap = MultiThreadAssetChangeInfoMgr::GetInstance().assetChangeDataMap_;
1523 auto iter = multiAssetMap.find(FAVORITE_IMAGE_ASSET_FILE_ID);
1524 EXPECT_TRUE(iter != multiAssetMap.end());
1525 auto data = iter->second;
1526 EXPECT_TRUE(data.count_ >= 2);
1527 EXPECT_TRUE(data.isMultiOperation_);
1528 ACCURATE_DEBUG("count[%{public}d]", data.count_);
1529 std::this_thread::sleep_for(chrono::milliseconds(100));
1530 });
1531
1532 taskTrash.join();
1533 taskTrash2.join();
1534 auto infos = MultiThreadAssetChangeInfoMgr::GetInstance().GetAssetChangeData(FAVORITE_IMAGE_ASSET_FILE_ID);
1535 EXPECT_TRUE(infos.first.fileId_ == INVALID_INT32_VALUE);
1536 EXPECT_TRUE(infos.second.fileId_ == INVALID_INT32_VALUE);
1537 }
1538
1539 HWTEST_F(AssetAccurateRefreshTest, AccurateRefreshAlbum_020, TestSize.Level2)
1540 {
1541 PrepareNormalAssets();
1542
1543 ACCURATE_DEBUG("taskTrash start");
1544 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1545 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1546 ValuesBucket value;
1547 int64_t dataTrashTime = 1000000;
1548 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1549 AssetAccurateRefresh assetRefresh("AccurateRefreshAlbum_020");
1550 int32_t changedRow = 0;
1551 auto ret = assetRefresh.Update(changedRow, value, predicates);
1552 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1553 EXPECT_TRUE(changedRow == 1);
1554 // album 刷新
1555 assetRefresh.RefreshAlbum();
1556 ACCURATE_DEBUG("taskTrash end");
1557 assetRefresh.Notify();
1558
1559 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1560 auto trashAlbumInfo = AccurateRefresh::GetAlbumInfo(TRASH_ALBUM_ID, g_rdbStore);
1561 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1562 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1563 EXPECT_TRUE(favoriteAlbumInfo.count_ == FAVORITE_ALBUM_COUNT - 1);
1564 EXPECT_TRUE(trashAlbumInfo.count_ == TRASH_ALBUM_COUNT + 1);
1565 EXPECT_TRUE(imageAlbumInfo.count_ == IMAGE_ALBUM_COUNT - 1);
1566 EXPECT_TRUE(ownerAlbumInfo.count_ == USER_ALBUM_COUNT - 1);
1567 }
1568
1569 HWTEST_F(AssetAccurateRefreshTest, IgnoreRefreshAlbum_021, TestSize.Level2)
1570 {
1571 PrepareNormalAssets();
1572
1573 ACCURATE_DEBUG("taskTrash start");
1574 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1575 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1576 ValuesBucket value;
1577 int64_t dataTrashTime = 1000000;
1578 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1579 AssetAccurateRefresh assetRefresh("IgnoreRefreshAlbum_021");
1580 int32_t changedRow = 0;
1581 auto ret = assetRefresh.Update(changedRow, value, predicates);
1582 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1583 EXPECT_TRUE(changedRow == 1);
1584
1585 auto timestamp = AlbumAccurateRefreshManager::GetInstance().GetCurrentRefreshTag();
1586 AlbumRefreshTimestamp albumTimestamp(timestamp + 100, timestamp + 100);
1587 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, true, albumTimestamp);
1588 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, false, albumTimestamp);
1589 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(TRASH_ALBUM_ID, true, albumTimestamp);
1590 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(TRASH_ALBUM_ID, false, albumTimestamp);
1591 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_ALBUM_ID, true, albumTimestamp);
1592 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(IMAGE_ALBUM_ID, false, albumTimestamp);
1593 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_IMAGE_ASSET_ALBUM_ID, true, albumTimestamp);
1594 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_IMAGE_ASSET_ALBUM_ID, false,
1595 albumTimestamp);
1596
1597 // album 刷新
1598 assetRefresh.RefreshAlbum();
1599 ACCURATE_DEBUG("taskTrash end");
1600 assetRefresh.Notify();
1601
1602 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1603 auto trashAlbumInfo = AccurateRefresh::GetAlbumInfo(TRASH_ALBUM_ID, g_rdbStore);
1604 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1605 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1606 EXPECT_TRUE(favoriteAlbumInfo.count_ == FAVORITE_ALBUM_COUNT);
1607 EXPECT_TRUE(trashAlbumInfo.count_ == TRASH_ALBUM_COUNT);
1608 EXPECT_TRUE(imageAlbumInfo.count_ == IMAGE_ALBUM_COUNT);
1609 EXPECT_TRUE(ownerAlbumInfo.count_ == USER_ALBUM_COUNT);
1610 }
1611
1612 HWTEST_F(AssetAccurateRefreshTest, ForceRefreshAlbum_021, TestSize.Level2)
1613 {
1614 PrepareNormalAssets();
1615
1616 ACCURATE_DEBUG("taskTrash start");
1617 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1618 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1619 ValuesBucket value;
1620 int64_t dataTrashTime = 1000000;
1621 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1622 AssetAccurateRefresh assetRefresh("ForceRefreshAlbum_021");
1623 int32_t changedRow = 0;
1624 auto ret = assetRefresh.Update(changedRow, value, predicates);
1625 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1626 EXPECT_TRUE(changedRow == 1);
1627
1628 auto iter = assetRefresh.dataManager_.changeDatas_.find(FAVORITE_IMAGE_ASSET_FILE_ID);
1629 EXPECT_TRUE(iter != assetRefresh.dataManager_.changeDatas_.end());
1630 auto changeData = iter->second;
1631 auto timestampStart = changeData.infoBeforeChange_.timestamp_;
1632 AlbumRefreshTimestamp albumTimestamp(timestampStart - 100, timestampStart);
1633 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, true, albumTimestamp);
1634 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, false, albumTimestamp);
1635
1636 // album 刷新
1637 assetRefresh.RefreshAlbum();
1638 ACCURATE_DEBUG("taskTrash end");
1639 assetRefresh.Notify();
1640
1641 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1642 auto trashAlbumInfo = AccurateRefresh::GetAlbumInfo(TRASH_ALBUM_ID, g_rdbStore);
1643 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1644 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1645 EXPECT_TRUE(favoriteAlbumInfo.count_ == 0);
1646 EXPECT_TRUE(trashAlbumInfo.count_ == TRASH_ALBUM_COUNT + 1);
1647 EXPECT_TRUE(imageAlbumInfo.count_ == IMAGE_ALBUM_COUNT - 1);
1648 EXPECT_TRUE(ownerAlbumInfo.count_ == USER_ALBUM_COUNT - 1);
1649 }
1650
1651 HWTEST_F(AssetAccurateRefreshTest, ForceRefreshAlbum_022, TestSize.Level2)
1652 {
1653 PrepareNormalAssets();
1654
1655 ACCURATE_DEBUG("taskTrash start");
1656 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1657 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1658 ValuesBucket value;
1659 int64_t dataTrashTime = 1000000;
1660 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1661 AssetAccurateRefresh assetRefresh("ForceRefreshAlbum_022");
1662 int32_t changedRow = 0;
1663 auto ret = assetRefresh.Update(changedRow, value, predicates);
1664 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1665 EXPECT_TRUE(changedRow == 1);
1666
1667 auto iter = assetRefresh.dataManager_.changeDatas_.find(FAVORITE_IMAGE_ASSET_FILE_ID);
1668 EXPECT_TRUE(iter != assetRefresh.dataManager_.changeDatas_.end());
1669 auto changeData = iter->second;
1670 auto timestampStart = changeData.infoBeforeChange_.timestamp_;
1671 auto timestampEnd = changeData.infoAfterChange_.timestamp_;
1672 AlbumRefreshTimestamp albumTimestamp(timestampStart - 100, timestampEnd + 100);
1673 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, true, albumTimestamp);
1674 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, false, albumTimestamp);
1675
1676 // album 刷新
1677 assetRefresh.RefreshAlbum();
1678 ACCURATE_DEBUG("taskTrash end");
1679 assetRefresh.Notify();
1680
1681 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1682 auto trashAlbumInfo = AccurateRefresh::GetAlbumInfo(TRASH_ALBUM_ID, g_rdbStore);
1683 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1684 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1685 EXPECT_TRUE(favoriteAlbumInfo.count_ == 0);
1686 EXPECT_TRUE(trashAlbumInfo.count_ == TRASH_ALBUM_COUNT + 1);
1687 EXPECT_TRUE(imageAlbumInfo.count_ == IMAGE_ALBUM_COUNT - 1);
1688 EXPECT_TRUE(ownerAlbumInfo.count_ == USER_ALBUM_COUNT - 1);
1689 }
1690
1691 HWTEST_F(AssetAccurateRefreshTest, ForceRefreshAlbum_023, TestSize.Level2)
1692 {
1693 PrepareNormalAssets();
1694
1695 ACCURATE_DEBUG("taskTrash start");
1696 RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1697 predicates.EqualTo(PhotoColumn::MEDIA_ID, FAVORITE_IMAGE_ASSET_FILE_ID);
1698 ValuesBucket value;
1699 int64_t dataTrashTime = 1000000;
1700 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
1701 AssetAccurateRefresh assetRefresh("ForceRefreshAlbum_023");
1702 int32_t changedRow = 0;
1703 auto ret = assetRefresh.Update(changedRow, value, predicates);
1704 EXPECT_TRUE(ret == ACCURATE_REFRESH_RET_OK);
1705 EXPECT_TRUE(changedRow == 1);
1706
1707 auto iter = assetRefresh.dataManager_.changeDatas_.find(FAVORITE_IMAGE_ASSET_FILE_ID);
1708 EXPECT_TRUE(iter != assetRefresh.dataManager_.changeDatas_.end());
1709 auto changeData = iter->second;
1710 auto timestampEnd = changeData.infoAfterChange_.timestamp_;
1711 AlbumRefreshTimestamp albumTimestamp(timestampEnd, timestampEnd + 100);
1712 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, true, albumTimestamp);
1713 AlbumAccurateRefreshManager::GetInstance().SetRefreshTimestamp(FAVORITE_ALBUM_ID, false, albumTimestamp);
1714
1715 // album 刷新
1716 assetRefresh.RefreshAlbum();
1717 ACCURATE_DEBUG("taskTrash end");
1718 assetRefresh.Notify();
1719
1720 auto favoriteAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_ALBUM_ID, g_rdbStore);
1721 auto trashAlbumInfo = AccurateRefresh::GetAlbumInfo(TRASH_ALBUM_ID, g_rdbStore);
1722 auto imageAlbumInfo = AccurateRefresh::GetAlbumInfo(IMAGE_ALBUM_ID, g_rdbStore);
1723 auto ownerAlbumInfo = AccurateRefresh::GetAlbumInfo(FAVORITE_IMAGE_ASSET_ALBUM_ID, g_rdbStore);
1724 EXPECT_TRUE(favoriteAlbumInfo.count_ == 0);
1725 EXPECT_TRUE(trashAlbumInfo.count_ == TRASH_ALBUM_COUNT + 1);
1726 EXPECT_TRUE(imageAlbumInfo.count_ == IMAGE_ALBUM_COUNT - 1);
1727 EXPECT_TRUE(ownerAlbumInfo.count_ == USER_ALBUM_COUNT - 1);
1728 }
1729
1730 } // namespace Media
1731 } // namespace OHOS