1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "medialibraryrefresh_fuzzer.h"
17
18 #include <cstdint>
19 #include <string>
20 #include <pixel_map.h>
21
22 #include <fuzzer/FuzzedDataProvider.h>
23 #include "medialibrary_restore.h"
24 #include "medialibrary_rdbstore.h"
25 #include "medialibrary_db_const.h"
26 #include "medialibrary_errno.h"
27 #include "media_file_utils.h"
28 #include "medialibrary_data_manager.h"
29 #include "medialibrary_unistore_manager.h"
30 #include "medialibrary_unittest_utils.h"
31 #include "notification_classification.h"
32 #include "notify_info_inner.h"
33 #include "media_change_info.h"
34 #include "notification_merging.h"
35 #include "notification_distribution.h"
36 #include "notify_info.h"
37 #include "media_observer_manager.h"
38 #include "media_datashare_stub_impl.h"
39 #include "data_ability_observer_interface.h"
40 #include "observer_info.h"
41 #include "data_ability_observer_stub.h"
42 #include "media_log.h"
43 #include "get_self_permissions.h"
44 #include "access_token.h"
45 #include "accesstoken_kit.h"
46 #include "token_setproc.h"
47 #include "media_file_utils.h"
48 #include "accurate_common_data.h"
49 #include "medialibrary_rdb_utils.h"
50 #include "medialibrary_command.h"
51 #include "asset_accurate_refresh.h"
52 #include "album_accurate_refresh.h"
53 #include "accurate_refresh_base.h"
54 #include "medialibrary_kvstore_manager.h"
55 #include "photo_album_column.h"
56 #include "photo_album_column.h"
57 #include "media_column.h"
58 #include <iostream>
59 #include <vector>
60 #include <algorithm>
61 #include <random>
62
63 namespace OHOS {
64 using namespace Media;
65 using namespace std;
66
67 FuzzedDataProvider *provider = nullptr;
68 std::shared_ptr<Media::MediaLibraryRdbStore> g_rdbStore;
69 static const int32_t NUM_BYTES = 1;
70 static const uint32_t MAX_ID = 10000;
71 static const int32_t RDB_OPERATION_MAX_SIZE = 3;
72 static const std::string ALBUM_SELECT_SQL_STR = "SELECT * FROM PhotoAlbum WHERE album_id = ";
73 static const std::string PHOTOS_DELETE_SQL_STR = "DELETE FROM Photos WHERE file_id = ";
74 static const std::string ALBUM_DELETE_SQL_STR = "DELETE FROM PhotoAlbum WHERE album_id = ";
75 static const std::string ALBUM_TABLE_NAME = "PhotoAlbum";
76 static const std::string PHOTO_TABLE_NAME = "Photos";
77
GetRdbOperation()78 static inline AccurateRefresh::RdbOperation GetRdbOperation()
79 {
80 int32_t value = provider->ConsumeIntegralInRange<int32_t>(0, RDB_OPERATION_MAX_SIZE);
81 return static_cast<AccurateRefresh::RdbOperation>(value);
82 }
83
SetTables()84 void SetTables()
85 {
86 // 创建Photos/PhotoAlbum表
87 vector<string> createTableSqlList = {
88 CREATE_PHOTO_ALBUM_TABLE,
89 CREATE_PHOTO_TABLE,
90 };
91 for (auto &createTableSql : createTableSqlList) {
92 if (g_rdbStore == nullptr) {
93 MEDIA_ERR_LOG("can not get g_rdbstore");
94 return;
95 }
96 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
97 if (ret != E_OK) {
98 MEDIA_ERR_LOG("Execute sql %{private}s failed", createTableSql.c_str());
99 return;
100 }
101 MEDIA_INFO_LOG("Execute sql %{private}s success", createTableSql.c_str());
102 }
103 MEDIA_INFO_LOG("SetTables");
104 }
105
Init()106 static void Init()
107 {
108 MediaLibraryUnitTestUtils::Init();
109 g_rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
110 if (g_rdbStore == nullptr) {
111 MEDIA_ERR_LOG("Start MediaLibraryPhotoOperationsTest failed, can not get rdbstore");
112 exit(1);
113 }
114 SetTables();
115 }
116
ClearKvStore()117 static inline void ClearKvStore()
118 {
119 Media::MediaLibraryKvStoreManager::GetInstance().CloseAllKvStore();
120 }
121
GetPhotoAssetChangeInfo()122 Media::AccurateRefresh::PhotoAssetChangeInfo GetPhotoAssetChangeInfo()
123 {
124 Media::AccurateRefresh::PhotoAssetChangeInfo assetChangeInfo = NORMAL_ASSET;
125 assetChangeInfo.isFavorite_ = provider->ConsumeBool();
126 assetChangeInfo.isHidden_ = provider->ConsumeBool();
127 assetChangeInfo.thumbnailVisible_ = MediaFileUtils::UTCTimeMilliSeconds();
128 assetChangeInfo.strongAssociation_ = provider->ConsumeIntegralInRange<int32_t>(0, 1);
129 assetChangeInfo.isTemp_ = provider->ConsumeBool();
130 assetChangeInfo.dateAddedMs_ = MediaFileUtils::UTCTimeMilliSeconds();
131 assetChangeInfo.fileId_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
132 assetChangeInfo.ownerAlbumId_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
133 assetChangeInfo.ownerAlbumUri_ = provider->ConsumeBytesAsString(NUM_BYTES);
134 return assetChangeInfo;
135 }
136
GetAlbumChangeInfo()137 Media::AccurateRefresh::AlbumChangeInfo GetAlbumChangeInfo()
138 {
139 Media::AccurateRefresh::AlbumChangeInfo albumChangeInfo;
140 albumChangeInfo.albumId_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
141 albumChangeInfo.imageCount_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
142 albumChangeInfo.videoCount_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
143 albumChangeInfo.albumType_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
144 albumChangeInfo.albumSubType_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
145 albumChangeInfo.count_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
146 albumChangeInfo.hiddenCount_ = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
147 albumChangeInfo.isCoverChange_ = provider->ConsumeBool();
148 albumChangeInfo.coverInfo_ = GetPhotoAssetChangeInfo();
149 albumChangeInfo.isHiddenCoverChange_ = provider->ConsumeBool();
150 albumChangeInfo.hiddenCoverInfo_ = GetPhotoAssetChangeInfo();
151 albumChangeInfo.coverDateTime_ = MediaFileUtils::UTCTimeMilliSeconds();
152 albumChangeInfo.hiddenCoverDateTime_ = MediaFileUtils::UTCTimeMilliSeconds();
153 albumChangeInfo.albumName_ = provider->ConsumeBytesAsString(NUM_BYTES);
154 return albumChangeInfo;
155 }
156
GetAssetValuesBucket(Media::AccurateRefresh::PhotoAssetChangeInfo & assetInfo)157 NativeRdb::ValuesBucket GetAssetValuesBucket(Media::AccurateRefresh::PhotoAssetChangeInfo &assetInfo)
158 {
159 NativeRdb::ValuesBucket value;
160 value.PutInt(PhotoColumn::MEDIA_ID, assetInfo.fileId_);
161 value.PutString(PhotoColumn::PHOTO_DATE_DAY, assetInfo.dateDay_);
162 value.PutInt(PhotoColumn::MEDIA_IS_FAV, static_cast<int32_t>(assetInfo.isFavorite_));
163 value.PutInt(PhotoColumn::MEDIA_TYPE, assetInfo.mediaType_);
164 value.PutInt(PhotoColumn::MEDIA_HIDDEN, assetInfo.isHidden_);
165 value.PutLong(PhotoColumn::MEDIA_DATE_TRASHED, assetInfo.dateTrashedMs_);
166 value.PutInt(PhotoColumn::PHOTO_STRONG_ASSOCIATION, assetInfo.strongAssociation_);
167 value.PutInt(PhotoColumn::PHOTO_THUMBNAIL_VISIBLE, assetInfo.thumbnailVisible_);
168 value.PutLong(PhotoColumn::MEDIA_DATE_ADDED, assetInfo.dateAddedMs_);
169 value.PutLong(PhotoColumn::MEDIA_DATE_TAKEN, assetInfo.dateTakenMs_);
170 value.PutInt(PhotoColumn::PHOTO_SUBTYPE, assetInfo.subType_);
171 value.PutInt(PhotoColumn::PHOTO_SYNC_STATUS, assetInfo.syncStatus_);
172 value.PutInt(PhotoColumn::PHOTO_CLEAN_FLAG, assetInfo.cleanFlag_);
173 value.PutInt(PhotoColumn::MEDIA_TIME_PENDING, assetInfo.timePending_);
174 value.PutInt(PhotoColumn::PHOTO_IS_TEMP, assetInfo.isTemp_);
175 value.PutInt(PhotoColumn::PHOTO_BURST_COVER_LEVEL, assetInfo.burstCoverLevel_);
176 value.PutInt(PhotoColumn::PHOTO_OWNER_ALBUM_ID, assetInfo.ownerAlbumId_);
177 value.PutLong(PhotoColumn::PHOTO_HIDDEN_TIME, assetInfo.hiddenTime_);
178 value.PutString(PhotoColumn::MEDIA_NAME, assetInfo.displayName_);
179 value.PutString(PhotoColumn::MEDIA_FILE_PATH, assetInfo.path_);
180 return value;
181 }
182
GetAlbumValuesBucket(Media::AccurateRefresh::AlbumChangeInfo & albumInfo)183 NativeRdb::ValuesBucket GetAlbumValuesBucket(Media::AccurateRefresh::AlbumChangeInfo &albumInfo)
184 {
185 NativeRdb::ValuesBucket value;
186 value.PutInt(PhotoAlbumColumns::ALBUM_ID, albumInfo.albumId_);
187 value.PutInt(PhotoAlbumColumns::ALBUM_TYPE, albumInfo.albumType_);
188 value.PutInt(PhotoAlbumColumns::ALBUM_SUBTYPE, albumInfo.albumSubType_);
189 value.PutInt(PhotoAlbumColumns::ALBUM_COUNT, albumInfo.count_);
190 value.PutInt(PhotoAlbumColumns::ALBUM_IMAGE_COUNT, albumInfo.imageCount_);
191 value.PutInt(PhotoAlbumColumns::ALBUM_VIDEO_COUNT, albumInfo.videoCount_);
192 value.PutString(PhotoAlbumColumns::ALBUM_COVER_URI, albumInfo.coverUri_);
193 value.PutInt(PhotoAlbumColumns::HIDDEN_COUNT, albumInfo.hiddenCount_);
194 value.PutString(PhotoAlbumColumns::HIDDEN_COVER, albumInfo.hiddenCoverUri_);
195 value.PutLong(PhotoAlbumColumns::COVER_DATE_TIME, albumInfo.coverDateTime_);
196 value.PutLong(PhotoAlbumColumns::HIDDEN_COVER_DATE_TIME, albumInfo.hiddenCoverDateTime_);
197 value.PutInt(PhotoAlbumColumns::ALBUM_DIRTY, albumInfo.dirty_);
198 value.PutString(PhotoAlbumColumns::ALBUM_NAME, albumInfo.albumName_);
199 return value;
200 }
201
SetAssetValuesBuckets(std::vector<NativeRdb::ValuesBucket> & valuesBuckets,Media::AccurateRefresh::PhotoAssetChangeInfo & assetInfo)202 void SetAssetValuesBuckets(std::vector<NativeRdb::ValuesBucket> &valuesBuckets,
203 Media::AccurateRefresh::PhotoAssetChangeInfo &assetInfo)
204 {
205 auto valuesBucket = GetAssetValuesBucket(assetInfo);
206 valuesBuckets.push_back(valuesBucket);
207 }
208
SetAlbumValuesBuckets(std::vector<NativeRdb::ValuesBucket> & valuesBuckets,Media::AccurateRefresh::AlbumChangeInfo & albumInfo)209 void SetAlbumValuesBuckets(std::vector<NativeRdb::ValuesBucket> &valuesBuckets,
210 Media::AccurateRefresh::AlbumChangeInfo &albumInfo)
211 {
212 auto valuesBucket = GetAlbumValuesBucket(albumInfo);
213 valuesBuckets.push_back(valuesBucket);
214 }
215
AssetInsertOperation()216 void AssetInsertOperation()
217 {
218 int64_t outRowId = 0;
219 Media::AccurateRefresh::PhotoAssetChangeInfo assetInfo = GetPhotoAssetChangeInfo();
220 AccurateRefresh::AssetAccurateRefresh assetRefresh("AssetInsertOperation");
221 Uri uri(provider->ConsumeBytesAsString(NUM_BYTES));
222 Media::MediaLibraryCommand cmd(uri);
223 cmd.SetTableName(PHOTO_TABLE_NAME);
224 cmd.SetValueBucket(GetAssetValuesBucket(assetInfo));
225 assetRefresh.Insert(cmd, outRowId);
226 assetRefresh.RefreshAlbum();
227 }
228
AssetBatchInsert()229 void AssetBatchInsert()
230 {
231 int64_t insertChangedRows = 0;
232 Media::AccurateRefresh::PhotoAssetChangeInfo assetInfo = GetPhotoAssetChangeInfo();
233 AccurateRefresh::AssetAccurateRefresh assetRefresh("AssetBatchInsert");
234 Uri uri(provider->ConsumeBytesAsString(NUM_BYTES));
235 Media::MediaLibraryCommand cmd(uri);
236 cmd.SetTableName(PHOTO_TABLE_NAME);
237 std::vector<NativeRdb::ValuesBucket> valuesBuckets;
238 SetAssetValuesBuckets(valuesBuckets, assetInfo);
239 assetRefresh.BatchInsert(cmd, insertChangedRows, valuesBuckets);
240 assetRefresh.RefreshAlbum();
241 }
242
AssetUpdate()243 void AssetUpdate()
244 {
245 int32_t changedRow = 0;
246 AccurateRefresh::AssetAccurateRefresh assetRefresh("AssetUpdate");
247 NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
248 auto newId = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
249 predicates.EqualTo(PhotoColumn::MEDIA_ID, newId);
250 NativeRdb::ValuesBucket value;
251 int64_t dataTrashTime = MediaFileUtils::UTCTimeMilliSeconds();
252 value.PutInt(PhotoColumn::MEDIA_DATE_TRASHED, dataTrashTime);
253 assetRefresh.Update(changedRow, value, predicates);
254 assetRefresh.RefreshAlbum();
255 }
256
AssetLogicalDeleteByCmd()257 void AssetLogicalDeleteByCmd()
258 {
259 int32_t changeRows = 0;
260 AccurateRefresh::AssetAccurateRefresh assetRefresh("AssetLogicalDeleteByCmd");
261 Uri uri(provider->ConsumeBytesAsString(NUM_BYTES));
262 MediaLibraryCommand cmd(uri);
263 cmd.SetTableName(PHOTO_TABLE_NAME);
264 auto predicates = cmd.GetAbsRdbPredicates();
265 predicates->SetWhereClause(PhotoAlbumColumns::ALBUM_SUBTYPE + " = ?");
266 int32_t instIndex = provider->ConsumeIntegralInRange<int32_t>(0, PHOTO_ALBUM_SUB_TYPE.size()-1);
267 predicates->SetWhereArgs({to_string(PHOTO_ALBUM_SUB_TYPE[instIndex])});
268 assetRefresh.LogicalDeleteReplaceByUpdate(cmd, changeRows);
269 assetRefresh.RefreshAlbum();
270 }
271
AssetExecuteSql()272 void AssetExecuteSql()
273 {
274 std::string deleteSql = PHOTOS_DELETE_SQL_STR + to_string(provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID));
275 std::shared_ptr<TransactionOperations> trans = make_shared<TransactionOperations>(__func__);
276 AccurateRefresh::AssetAccurateRefresh assetRefresh("AssetLogicalDeleteByCmd", trans);
277 assetRefresh.Init();
278 assetRefresh.ExecuteSql(deleteSql, GetRdbOperation());
279 assetRefresh.RefreshAlbum();
280 }
281
AlbumInsertOperation()282 void AlbumInsertOperation()
283 {
284 int64_t outRowId = 0;
285 Media::AccurateRefresh::AlbumChangeInfo albumInfo = GetAlbumChangeInfo();
286 AccurateRefresh::AlbumAccurateRefresh albumRefresh("AlbumInsertOperation");
287 Uri uri(provider->ConsumeBytesAsString(NUM_BYTES));
288 Media::MediaLibraryCommand cmd(uri);
289 cmd.SetTableName(ALBUM_TABLE_NAME);
290 cmd.SetValueBucket(GetAlbumValuesBucket(albumInfo));
291 albumRefresh.Insert(cmd, outRowId);
292 }
293
AlbumLogicalDeleteByCmd()294 void AlbumLogicalDeleteByCmd()
295 {
296 int32_t deletedRows = 0;
297 Media::AccurateRefresh::AlbumChangeInfo albumInfo = GetAlbumChangeInfo();
298 AccurateRefresh::AlbumAccurateRefresh albumRefresh("AlbumLogicalDeleteByCmd");
299 Uri uri(provider->ConsumeBytesAsString(NUM_BYTES));
300 Media::MediaLibraryCommand cmd(uri);
301 cmd.SetTableName(ALBUM_TABLE_NAME);
302 auto predicates = cmd.GetAbsRdbPredicates();
303 predicates->SetWhereClause(PhotoAlbumColumns::ALBUM_SUBTYPE + " = ?");
304 int32_t instIndex = provider->ConsumeIntegralInRange<int32_t>(0, PHOTO_ALBUM_SUB_TYPE.size()-1);
305 predicates->SetWhereArgs({to_string(PHOTO_ALBUM_SUB_TYPE[instIndex])});
306 albumRefresh.LogicalDeleteReplaceByUpdate(cmd, deletedRows);
307 }
308
AlbumLogicalDeleteByPredicates()309 void AlbumLogicalDeleteByPredicates()
310 {
311 int32_t deletedRows = 0;
312 Media::AccurateRefresh::AlbumChangeInfo albumInfo = GetAlbumChangeInfo();
313 AccurateRefresh::AlbumAccurateRefresh albumRefresh("AlbumLogicalDeleteByPredicates");
314 NativeRdb::RdbPredicates predicates(ALBUM_TABLE_NAME);
315 int32_t instIndex = provider->ConsumeIntegralInRange<int32_t>(0, PHOTO_ALBUM_SUB_TYPE.size()-1);
316 predicates.EqualTo(PhotoAlbumColumns::ALBUM_SUBTYPE, to_string(PHOTO_ALBUM_SUB_TYPE[instIndex]));
317 albumRefresh.LogicalDeleteReplaceByUpdate(predicates, deletedRows);
318 }
319
AlbumBatchInsert()320 void AlbumBatchInsert()
321 {
322 int64_t insertChangedRows = 0;
323 Media::AccurateRefresh::AlbumChangeInfo albumInfo = GetAlbumChangeInfo();
324 AccurateRefresh::AlbumAccurateRefresh albumRefresh("AlbumBatchInsert");
325 Uri uri(provider->ConsumeBytesAsString(NUM_BYTES));
326 Media::MediaLibraryCommand cmd(uri);
327 cmd.SetTableName(ALBUM_TABLE_NAME);
328 cmd.SetValueBucket(GetAlbumValuesBucket(albumInfo));
329 std::vector<NativeRdb::ValuesBucket> valuesBuckets;
330 SetAlbumValuesBuckets(valuesBuckets, albumInfo);
331 albumRefresh.BatchInsert(cmd, insertChangedRows, valuesBuckets);
332 }
333
AlbumUpdate()334 void AlbumUpdate()
335 {
336 int32_t changedRows = 0;
337 Media::AccurateRefresh::AlbumChangeInfo albumInfo = GetAlbumChangeInfo();
338 AccurateRefresh::AlbumAccurateRefresh albumRefresh("AlbumUpdate");
339 Uri uri(provider->ConsumeBytesAsString(NUM_BYTES));
340 Media::MediaLibraryCommand cmd(uri);
341 cmd.SetTableName(ALBUM_TABLE_NAME);
342 cmd.SetValueBucket(GetAlbumValuesBucket(albumInfo));
343 albumRefresh.Update(cmd, changedRows);
344 }
345
AlbumExecuteSql()346 void AlbumExecuteSql()
347 {
348 int64_t outRowId = 0;
349 auto oldAlbumId = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
350 auto newAlbumId = provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID);
351 std::string initSql = ALBUM_SELECT_SQL_STR + to_string(oldAlbumId);
352 std::string deleteSql = ALBUM_DELETE_SQL_STR + to_string(oldAlbumId);
353 AccurateRefresh::RdbOperation operation = GetRdbOperation();
354 std::shared_ptr<TransactionOperations> trans = make_shared<TransactionOperations>(__func__);
355 AccurateRefresh::AlbumAccurateRefresh albumRefresh("AlbumExecuteSql", trans);
356
357 std::vector<NativeRdb::ValuesBucket> valuesBuckets;
358 Media::AccurateRefresh::AlbumChangeInfo albumInfo = GetAlbumChangeInfo();
359 albumInfo.albumId_ = newAlbumId;
360 auto value = GetAlbumValuesBucket(albumInfo);
361 albumRefresh.Insert(outRowId, ALBUM_TABLE_NAME, value);
362
363 NativeRdb::RdbPredicates rdbPredicatesAlbum(ALBUM_TABLE_NAME);
364 rdbPredicatesAlbum.EqualTo(PhotoAlbumColumns::ALBUM_ID, oldAlbumId);
365 albumRefresh.Init(rdbPredicatesAlbum);
366 albumRefresh.ExecuteSql(deleteSql, operation);
367 }
368
AlbumExecuteForLastInsertedRowId()369 void AlbumExecuteForLastInsertedRowId()
370 {
371 auto insertSql = ALBUM_SELECT_SQL_STR + to_string(provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID));
372 AccurateRefresh::RdbOperation operation = GetRdbOperation();
373 AccurateRefresh::AlbumAccurateRefresh albumRefresh("AlbumExecuteForLastInsertedRowId");
374 albumRefresh.Init();
375 vector<NativeRdb::ValueObject> valueObjects = {to_string(provider->ConsumeIntegralInRange<int32_t>(0, MAX_ID))};
376 albumRefresh.ExecuteForLastInsertedRowId(insertSql, valueObjects, operation);
377 }
378
AssetAccurateRefreshFuzzerTest()379 static void AssetAccurateRefreshFuzzerTest()
380 {
381 AssetInsertOperation();
382 AssetBatchInsert();
383 AssetUpdate();
384 AssetLogicalDeleteByCmd();
385 AssetExecuteSql();
386 }
387
AlbumAccurateRefreshFuzzerTest()388 static void AlbumAccurateRefreshFuzzerTest()
389 {
390 AlbumInsertOperation();
391 AlbumLogicalDeleteByCmd();
392 AlbumLogicalDeleteByPredicates();
393 AlbumBatchInsert();
394 AlbumUpdate();
395 AlbumExecuteSql();
396 AlbumExecuteForLastInsertedRowId();
397 }
398
399 } // namespace OHOS
400
LLVMFuzzerInitialize(int * argc,char *** argv)401 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
402 {
403 OHOS::Init();
404 return 0;
405 }
406
407 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)408 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
409 {
410 /* Run your code on data */
411 FuzzedDataProvider provider(data, size);
412 OHOS::provider = &provider;
413 if (data == nullptr) {
414 return 0;
415 }
416 OHOS::AssetAccurateRefreshFuzzerTest();
417 OHOS::AlbumAccurateRefreshFuzzerTest();
418 OHOS::ClearKvStore();
419 return 0;
420 }