1 /*
2  * Copyright (c) 2022 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 "resmgr_fuzzer.h"
17 
18 #include <string>
19 #include <securec.h>
20 #include <vector>
21 #include "resource_manager.h"
22 
23 #undef private
24 
25 using namespace std;
26 using namespace OHOS::Global::Resource;
27 
28 namespace OHOS {
29 
30     constexpr int SINGULAR_NUM = 1;
31     constexpr int PLURAL_NUM = 2;
32 
AddResourceFuzzTest(const char * data,size_t size,ResourceManager * rm)33     bool AddResourceFuzzTest(const char* data, size_t size, ResourceManager *rm)
34     {
35         bool result = false;
36         if (size > 0) {
37             std::string testName(data, size);
38             result = rm->AddResource(testName.c_str());
39         }
40         return result;
41     }
42 
RemoveResourceFuzzTest(const char * data,size_t size,ResourceManager * rm)43     bool RemoveResourceFuzzTest(const char* data, size_t size, ResourceManager *rm)
44     {
45         bool result = false;
46         std::vector<std::string> overlayPaths;
47         if (size > 0) {
48             std::string testName(data, size);
49             result = rm->RemoveResource(testName.c_str(), overlayPaths);
50         }
51         return result;
52     }
53 
AddAppOverlayFuzzTest(const char * data,size_t size,ResourceManager * rm)54     bool AddAppOverlayFuzzTest(const char* data, size_t size, ResourceManager *rm)
55     {
56         bool result = false;
57         if (size > 0) {
58             std::string testName(data, size);
59             result = rm->AddAppOverlay(testName.c_str());
60         }
61         return result;
62     }
63 
RemoveAppOverlayFuzzTest(const char * data,size_t size,ResourceManager * rm)64     bool RemoveAppOverlayFuzzTest(const char* data, size_t size, ResourceManager *rm)
65     {
66         bool result = false;
67         if (size > 0) {
68             std::string testName(data, size);
69             result = rm->RemoveAppOverlay(testName.c_str());
70         }
71         return result;
72     }
73 
GetStringByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)74     bool GetStringByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
75     {
76         bool result = false;
77         if (size > 0) {
78             uint32_t testId = static_cast<uint32_t>(atoi(data));
79             std::string extraInfo = "";
80             result = rm->GetStringById(testId, extraInfo);
81         }
82         return result;
83     }
84 
GetStringByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)85     bool GetStringByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
86     {
87         bool result = false;
88         if (size > 0) {
89             std::string testName(data, size);
90             std::string extraInfo = "";
91             result = rm->GetStringByName(testName.c_str(), extraInfo);
92         }
93         return result;
94     }
95 
GetStringArrayByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)96     bool GetStringArrayByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
97     {
98         bool result = false;
99         if (size > 0) {
100             uint32_t testId = static_cast<uint32_t>(atoi(data));
101             std::vector<std::string> outValue;
102             result = rm->GetStringArrayById(testId, outValue);
103         }
104         return result;
105     }
106 
GetStringArrayByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)107     bool GetStringArrayByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
108     {
109         bool result = false;
110         if (size > 0) {
111             std::string testName(data, size);
112             std::vector<std::string> outValue;
113             result = rm->GetStringArrayByName(testName.c_str(), outValue);
114         }
115         return result;
116     }
117 
GetPatternByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)118     bool GetPatternByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
119     {
120         bool result = false;
121         if (size > 0) {
122             uint32_t testId = static_cast<uint32_t>(atoi(data));
123             std::map<std::string, std::string> outValue;
124             result = rm->GetPatternById(testId, outValue);
125         }
126         return result;
127     }
128 
GetPatternByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)129     bool GetPatternByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
130     {
131         bool result = false;
132         if (size > 0) {
133             std::string testName(data, size);
134             std::map<std::string, std::string> outValue;
135             result = rm->GetPatternByName(testName.c_str(), outValue);
136         }
137         return result;
138     }
139 
GetPluralStringByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)140     bool GetPluralStringByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
141     {
142         bool result = false;
143         if (size > 0) {
144             uint32_t testId = static_cast<uint32_t>(atoi(data));
145             std::string outValue = "";
146             result = rm->GetPluralStringById(testId, SINGULAR_NUM, outValue);
147         }
148         return result;
149     }
150 
GetPluralStringByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)151     bool GetPluralStringByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
152     {
153         bool result = false;
154         if (size > 0) {
155             std::string testName(data, size);
156             std::string outValue = "";
157             result = rm->GetPluralStringByName(testName.c_str(), PLURAL_NUM, outValue);
158         }
159         return result;
160     }
161 
GetThemeByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)162     bool GetThemeByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
163     {
164         bool result = false;
165         if (size > 0) {
166             uint32_t testId = static_cast<uint32_t>(atoi(data));
167             std::map<std::string, std::string> outValue;
168             result = rm->GetThemeById(testId, outValue);
169         }
170         return result;
171     }
172 
GetThemeByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)173     bool GetThemeByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
174     {
175         bool result = false;
176         if (size > 0) {
177             std::string testName(data, size);
178             std::map<std::string, std::string> outValue;
179             result = rm->GetThemeByName(testName.c_str(), outValue);
180         }
181         return result;
182     }
183 
GetIntegerByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)184     bool GetIntegerByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
185     {
186         bool result = false;
187         if (size > 0) {
188             uint32_t testId = static_cast<uint32_t>(atoi(data));
189             int outValue;
190             result = rm->GetIntegerById(testId, outValue);
191         }
192         return result;
193     }
194 
GetIntegerByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)195     bool GetIntegerByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
196     {
197         bool result = false;
198         if (size > 0) {
199             std::string testName(data, size);
200             int outValue;
201             result = rm->GetIntegerByName(testName.c_str(), outValue);
202         }
203         return result;
204     }
205 
GetBooleanByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)206     bool GetBooleanByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
207     {
208         bool result = false;
209         if (size > 0) {
210             uint32_t testId = static_cast<uint32_t>(atoi(data));
211             bool outValue;
212             result = rm->GetBooleanById(testId, outValue);
213         }
214         return result;
215     }
216 
GetBooleanByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)217     bool GetBooleanByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
218     {
219         bool result = false;
220         if (size > 0) {
221             std::string testName(data, size);
222             bool outValue = false;
223             result = rm->GetBooleanByName(testName.c_str(), outValue);
224         }
225         return result;
226     }
227 
GetFloatByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)228     bool GetFloatByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
229     {
230         bool result = false;
231         if (size > 0) {
232             uint32_t testId = static_cast<uint32_t>(atoi(data));
233             float outValue;
234             result = rm->GetFloatById(testId, outValue);
235         }
236         return result;
237     }
238 
GetFloatByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)239     bool GetFloatByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
240     {
241         bool result = false;
242         if (size > 0) {
243             std::string testName(data, size);
244             float outValue = 0.0f;
245             result = rm->GetFloatByName(testName.c_str(), outValue);
246         }
247         return result;
248     }
249 
GetIntArrayByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)250     bool GetIntArrayByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
251     {
252         bool result = false;
253         if (size > 0) {
254             uint32_t testId = static_cast<uint32_t>(atoi(data));
255             std::vector<int> outValue;
256             result = rm->GetIntArrayById(testId, outValue);
257         }
258         return result;
259     }
260 
GetIntArrayByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)261     bool GetIntArrayByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
262     {
263         bool result = false;
264         if (size > 0) {
265             std::string testName(data, size);
266             std::vector<int> outValue;
267             result = rm->GetIntArrayByName(testName.c_str(), outValue);
268         }
269         return result;
270     }
271 
GetMediaByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)272     bool GetMediaByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
273     {
274         bool result = false;
275         if (size > 0) {
276             uint32_t testId = static_cast<uint32_t>(atoi(data));
277             std::string outValue = "";
278             result = rm->GetMediaById(testId, outValue);
279         }
280         return result;
281     }
282 
GetMediaByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)283     bool GetMediaByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
284     {
285         bool result = false;
286         if (size > 0) {
287             std::string testName(data, size);
288             std::string outValue = "";
289             result = rm->GetMediaByName(testName.c_str(), outValue);
290         }
291         return result;
292     }
293 
GetRawFilePathByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)294     bool GetRawFilePathByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
295     {
296         bool result = false;
297         if (size > 0) {
298             std::string testName(data, size);
299             std::string outValue = "";
300             result = rm->GetRawFilePathByName(testName.c_str(), outValue);
301         }
302         return result;
303     }
304 
GetRawFileDescriptorFuzzTest(const char * data,size_t size,ResourceManager * rm)305     bool GetRawFileDescriptorFuzzTest(const char* data, size_t size, ResourceManager *rm)
306     {
307         bool result = false;
308         if (size > 0) {
309             std::string testName(data, size);
310             ResourceManager::RawFileDescriptor outValue;
311             result = rm->GetRawFileDescriptor(testName.c_str(), outValue);
312         }
313         return result;
314     }
315 
GetRawFdNdkFromHapFuzzTest(const char * data,size_t size,ResourceManager * rm)316     bool GetRawFdNdkFromHapFuzzTest(const char* data, size_t size, ResourceManager *rm)
317     {
318         bool result = false;
319         if (size > 0) {
320             std::string testName(data, size);
321             ResourceManager::RawFileDescriptor outValue;
322             result = rm->GetRawFdNdkFromHap(testName.c_str(), outValue);
323         }
324         return result;
325     }
326 
CloseRawFileDescriptorFuzzTest(const char * data,size_t size,ResourceManager * rm)327     bool CloseRawFileDescriptorFuzzTest(const char* data, size_t size, ResourceManager *rm)
328     {
329         bool result = false;
330         if (size > 0) {
331             std::string testName(data, size);
332             result = rm->CloseRawFileDescriptor(testName.c_str());
333         }
334         return result;
335     }
336 
GetMediaDataByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)337     bool GetMediaDataByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
338     {
339         bool result = false;
340         if (size > 0) {
341             uint32_t testId = static_cast<uint32_t>(atoi(data));
342             size_t len = 0;
343             std::unique_ptr<uint8_t[]> outValue;
344             result = rm->GetMediaDataById(testId, len, outValue);
345         }
346         return result;
347     }
348 
GetMediaDataByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)349     bool GetMediaDataByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
350     {
351         bool result = false;
352         if (size > 0) {
353             std::string testName(data, size);
354             size_t len = 0;
355             std::unique_ptr<uint8_t[]> outValue;
356             result = rm->GetMediaDataByName(testName.c_str(), len, outValue);
357         }
358         return result;
359     }
360 
GetMediaBase64DataByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)361     bool GetMediaBase64DataByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
362     {
363         bool result = false;
364         if (size > 0) {
365             uint32_t testId = static_cast<uint32_t>(atoi(data));
366             std::string outValue;
367             result = rm->GetMediaBase64DataById(testId, outValue);
368         }
369         return result;
370     }
371 
GetMediaBase64DataByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)372     bool GetMediaBase64DataByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
373     {
374         bool result = false;
375         if (size > 0) {
376             std::string testName(data, size);
377             std::string outValue;
378             result = rm->GetMediaBase64DataByName(testName.c_str(), outValue);
379         }
380         return result;
381     }
382 
GetProfileDataByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)383     bool GetProfileDataByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
384     {
385         bool result = false;
386         if (size > 0) {
387             uint32_t testId = static_cast<uint32_t>(atoi(data));
388             size_t len = 0;
389             std::unique_ptr<uint8_t[]> outValue;
390             result = rm->GetProfileDataById(testId, len, outValue);
391         }
392         return result;
393     }
394 
GetProfileDataByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)395     bool GetProfileDataByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
396     {
397         bool result = false;
398         if (size > 0) {
399             std::string testName(data, size);
400             size_t len = 0;
401             std::unique_ptr<uint8_t[]> outValue;
402             result = rm->GetProfileDataByName(testName.c_str(), len, outValue);
403         }
404         return result;
405     }
406 
GetRawFileFromHapFuzzTest(const char * data,size_t size,ResourceManager * rm)407     bool GetRawFileFromHapFuzzTest(const char* data, size_t size, ResourceManager *rm)
408     {
409         bool result = false;
410         if (size > 0) {
411             std::string testName(data, size);
412             size_t len = 0;
413             std::unique_ptr<uint8_t[]> outValue;
414             result = rm->GetRawFileFromHap(testName.c_str(), len, outValue);
415         }
416         return result;
417     }
418 
GetRawFileDescriptorFromHapFuzzTest(const char * data,size_t size,ResourceManager * rm)419     bool GetRawFileDescriptorFromHapFuzzTest(const char* data, size_t size, ResourceManager *rm)
420     {
421         bool result = false;
422         if (size > 0) {
423             std::string testName(data, size);
424             ResourceManager::RawFileDescriptor outValue;
425             result = rm->GetRawFileDescriptorFromHap(testName.c_str(), outValue);
426         }
427         return result;
428     }
429 
IsLoadHapFuzzTest(const char * data,size_t size,ResourceManager * rm)430     bool IsLoadHapFuzzTest(const char* data, size_t size, ResourceManager *rm)
431     {
432         bool result = false;
433         if (size > 0) {
434             std::string testName(data, size);
435             result = rm->IsLoadHap(testName);
436         }
437         return result;
438     }
439 
GetRawFileListFuzzTest(const char * data,size_t size,ResourceManager * rm)440     bool GetRawFileListFuzzTest(const char* data, size_t size, ResourceManager *rm)
441     {
442         bool result = false;
443         if (size > 0) {
444             std::string testName(data, size);
445             std::vector<std::string> outValue;
446             result = rm->GetRawFileList(testName.c_str(), outValue);
447         }
448         return result;
449     }
450 
GetResIdFuzzTest(const char * data,size_t size,ResourceManager * rm)451     bool GetResIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
452     {
453         bool result = false;
454         if (size > 0) {
455             uint32_t testId = static_cast<uint32_t>(atoi(data));
456             std::string testName(data, size);
457             result = rm->GetResId(testName.c_str(), testId);
458         }
459         return result;
460     }
461 
GetThemeIconsFuzzTest(const char * data,size_t size,ResourceManager * rm)462     bool GetThemeIconsFuzzTest(const char* data, size_t size, ResourceManager *rm)
463     {
464         bool result = false;
465         if (size > 0) {
466             uint32_t testId = static_cast<uint32_t>(atoi(data));
467             std::pair<std::unique_ptr<uint8_t[]>, size_t> foregroundInfo;
468             std::pair<std::unique_ptr<uint8_t[]>, size_t> backgroundInfo;
469             result = rm->GetThemeIcons(testId, foregroundInfo, backgroundInfo);
470         }
471         return result;
472     }
473 
GetStringFormatByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)474     bool GetStringFormatByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
475     {
476         bool result = false;
477         if (size > 0) {
478             uint32_t testId = static_cast<uint32_t>(atoi(data));
479             std::string outValue = "";
480             result = rm->GetStringFormatById(outValue, testId);
481         }
482         return result;
483     }
484 
GetColorByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)485     bool GetColorByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
486     {
487         bool result = false;
488         if (size > 0) {
489             uint32_t testId = static_cast<uint32_t>(atoi(data));
490             uint32_t outValue = 0;
491             result = rm->GetColorById(testId, outValue);
492         }
493         return result;
494     }
495 
GetColorByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)496     bool GetColorByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
497     {
498         bool result = false;
499         if (size > 0) {
500             std::string testName(data, size);
501             uint32_t outValue = 0;
502             result = rm->GetColorByName(testName.c_str(), outValue);
503         }
504         return result;
505     }
506 
GetSymbolByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)507     bool GetSymbolByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
508     {
509         bool result = false;
510         if (size > 0) {
511             uint32_t testId = static_cast<uint32_t>(atoi(data));
512             uint32_t outValue = 0;
513             result = rm->GetSymbolById(testId, outValue);
514         }
515         return result;
516     }
517 
GetSymbolByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)518     bool GetSymbolByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
519     {
520         bool result = false;
521         if (size > 0) {
522             std::string testName(data, size);
523             uint32_t outValue = 0;
524             result = rm->GetSymbolByName(testName.c_str(), outValue);
525         }
526         return result;
527     }
528 
GetProfileByIdFuzzTest(const char * data,size_t size,ResourceManager * rm)529     bool GetProfileByIdFuzzTest(const char* data, size_t size, ResourceManager *rm)
530     {
531         bool result = false;
532         if (size > 0) {
533             uint32_t testId = static_cast<uint32_t>(atoi(data));
534             std::string outValue;
535             result = rm->GetProfileById(testId, outValue);
536         }
537         return result;
538     }
539 
GetProfileByNameFuzzTest(const char * data,size_t size,ResourceManager * rm)540     bool GetProfileByNameFuzzTest(const char* data, size_t size, ResourceManager *rm)
541     {
542         bool result = false;
543         if (size > 0) {
544             std::string testName(data, size);
545             std::string outValue;
546             result = rm->GetProfileByName(testName.c_str(), outValue);
547         }
548         return result;
549     }
550 
ResourceManagerImplAdd(const char * data,size_t size,ResourceManager * rm)551     void ResourceManagerImplAdd(const char* data, size_t size, ResourceManager *rm)
552     {
553         AddResourceFuzzTest(data, size, rm);
554         RemoveResourceFuzzTest(data, size, rm);
555         AddAppOverlayFuzzTest(data, size, rm);
556         RemoveAppOverlayFuzzTest(data, size, rm);
557         GetStringByNameFuzzTest(data, size, rm);
558         GetStringArrayByNameFuzzTest(data, size, rm);
559         GetPatternByIdFuzzTest(data, size, rm);
560         GetPatternByNameFuzzTest(data, size, rm);
561         GetPluralStringByIdFuzzTest(data, size, rm);
562         GetPluralStringByNameFuzzTest(data, size, rm);
563         GetThemeByIdFuzzTest(data, size, rm);
564         GetThemeByNameFuzzTest(data, size, rm);
565         GetBooleanByNameFuzzTest(data, size, rm);
566         GetFloatByNameFuzzTest(data, size, rm);
567         GetIntArrayByIdFuzzTest(data, size, rm);
568         GetIntArrayByNameFuzzTest(data, size, rm);
569         GetRawFilePathByNameFuzzTest(data, size, rm);
570         GetRawFileDescriptorFuzzTest(data, size, rm);
571         GetRawFdNdkFromHapFuzzTest(data, size, rm);
572         CloseRawFileDescriptorFuzzTest(data, size, rm);
573         GetMediaDataByIdFuzzTest(data, size, rm);
574         GetMediaDataByNameFuzzTest(data, size, rm);
575         GetMediaBase64DataByIdFuzzTest(data, size, rm);
576         GetMediaBase64DataByNameFuzzTest(data, size, rm);
577     }
578 
ResourceManagerImplFuzzTest(const char * data,size_t size)579     void ResourceManagerImplFuzzTest(const char* data, size_t size)
580     {
581         ResourceManager *rm = CreateResourceManager();
582         if (rm == nullptr) {
583             return;
584         }
585         ResourceManagerImplAdd(data, size, rm);
586         GetProfileDataByIdFuzzTest(data, size, rm);
587         GetProfileDataByNameFuzzTest(data, size, rm);
588         GetRawFileFromHapFuzzTest(data, size, rm);
589         GetRawFileDescriptorFromHapFuzzTest(data, size, rm);
590         IsLoadHapFuzzTest(data, size, rm);
591         GetRawFileListFuzzTest(data, size, rm);
592         GetResIdFuzzTest(data, size, rm);
593         GetThemeIconsFuzzTest(data, size, rm);
594         GetColorByNameFuzzTest(data, size, rm);
595         GetSymbolByIdFuzzTest(data, size, rm);
596         GetSymbolByNameFuzzTest(data, size, rm);
597         GetProfileByIdFuzzTest(data, size, rm);
598         GetProfileByNameFuzzTest(data, size, rm);
599         GetStringByIdFuzzTest(data, size, rm);
600         GetStringArrayByIdFuzzTest(data, size, rm);
601         GetIntegerByIdFuzzTest(data, size, rm);
602         GetIntegerByNameFuzzTest(data, size, rm);
603         GetBooleanByIdFuzzTest(data, size, rm);
604         GetFloatByIdFuzzTest(data, size, rm);
605         GetMediaByIdFuzzTest(data, size, rm);
606         GetMediaByNameFuzzTest(data, size, rm);
607         GetStringFormatByIdFuzzTest(data, size, rm);
608         GetColorByIdFuzzTest(data, size, rm);
609         delete rm;
610         return;
611     }
612 }
613 
614 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)615 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
616 {
617     /* Run your code on data */
618     if (data == nullptr) {
619         return 0;
620     }
621 
622     char* ch = (char *)malloc(size + 1);
623     if (ch == nullptr) {
624         return 0;
625     }
626 
627     (void)memset_s(ch, size, 0x00, size);
628     if (memcpy_s(ch, size, data, size) != 0) {
629         free(ch);
630         ch = nullptr;
631         return 0;
632     }
633     OHOS::ResourceManagerImplFuzzTest(ch, size);
634     free(ch);
635     ch = nullptr;
636     return 0;
637 }
638 
639