1 /*
2 * Copyright (c) 2024 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 "fuzzer/FuzzedDataProvider.h"
17 #include "napi/native_api.h"
18 #include "message_parcel.h"
19 #include "scanhelper_fuzzer.h"
20 #include "scan_option_descriptor.h"
21 #include "scan_option_value.h"
22 #include "scan_parameters.h"
23 #include "scan_progress.h"
24 #include "scanner_info.h"
25 #include "scan_range.h"
26 #include "scan_option_descriptor_helper.h"
27 #include "scan_option_value_helper.h"
28 #include "scan_parameters_helper.h"
29 #include "scan_progress_helper.h"
30 #include "scan_range_helper.h"
31 #include "scanner_info_helper.h"
32
33 namespace OHOS {
34 namespace Scan {
35 constexpr uint8_t MAX_STRING_LENGTH = 255;
36 constexpr int MAX_SET_NUMBER = 100;
37 constexpr size_t FOO_MAX_LEN = 1024;
38 constexpr size_t U32_AT_SIZE = 4;
39
TestSetOptionName(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)40 void TestSetOptionName(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
41 {
42 ScanOptionDescriptor scanOptDes;
43 std::string optionName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
44 scanOptDes.SetOptionName(optionName);
45 optionName = scanOptDes.GetOptionName();
46 }
47
TestSetOptionTitle(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)48 void TestSetOptionTitle(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
49 {
50 ScanOptionDescriptor scanOptDes;
51 std::string optionTitle = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
52 scanOptDes.SetOptionTitle(optionTitle);
53 optionTitle = scanOptDes.GetOptionTitle();
54 }
55
TestSetOptionDesc(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)56 void TestSetOptionDesc(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
57 {
58 ScanOptionDescriptor scanOptDes;
59 std::string optionDesc = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
60 scanOptDes.SetOptionDesc(optionDesc);
61 optionDesc = scanOptDes.GetOptionDesc();
62 }
63
TestSetOptionType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)64 void TestSetOptionType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
65 {
66 ScanOptionDescriptor scanOptDes;
67 uint32_t optionType = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
68 scanOptDes.SetOptionType(optionType);
69 optionType = scanOptDes.GetOptionType();
70 }
71
TestSetOptionUnit(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)72 void TestSetOptionUnit(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
73 {
74 ScanOptionDescriptor scanOptDes;
75 uint32_t optionUnit = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
76 scanOptDes.SetOptionUnit(optionUnit);
77 optionUnit = scanOptDes.GetOptionUnit();
78 }
79
TestSetOptionSize(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)80 void TestSetOptionSize(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
81 {
82 ScanOptionDescriptor scanOptDes;
83 int32_t optionSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
84 scanOptDes.SetOptionSize(optionSize);
85 optionSize = scanOptDes.GetOptionSize();
86 }
87
TestSetOptionCap(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)88 void TestSetOptionCap(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
89 {
90 ScanOptionDescriptor scanOptDes;
91 int32_t optionCap = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
92 scanOptDes.SetOptionCap(optionCap);
93 optionCap = scanOptDes.GetOptionCap();
94 }
95
TestSetOptionConstraintType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)96 void TestSetOptionConstraintType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
97 {
98 ScanOptionDescriptor scanOptDes;
99 uint32_t optionConstraintType = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
100 scanOptDes.SetOptionConstraintType(optionConstraintType);
101 optionConstraintType = scanOptDes.GetOptionConstraintType();
102 }
103
TestSetOptionConstraintString(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)104 void TestSetOptionConstraintString(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
105 {
106 ScanOptionDescriptor scanOptDes;
107 std::vector<std::string> optionConstraintString;
108 int32_t vectorSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
109 for (int i = 0; i< vectorSize; i++) {
110 std::string teststr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
111 optionConstraintString.emplace_back(teststr);
112 }
113 scanOptDes.SetOptionConstraintString(optionConstraintString);
114 scanOptDes.GetOptionConstraintString(optionConstraintString);
115 }
116
TestSetOptionConstraintNumber(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)117 void TestSetOptionConstraintNumber(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
118 {
119 ScanOptionDescriptor scanOptDes;
120 std::vector<int32_t> optionConstraintNumber;
121 int32_t vectorSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
122 for (int i = 0; i< vectorSize; i++) {
123 int32_t testNumber = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
124 optionConstraintNumber.emplace_back(testNumber);
125 }
126 scanOptDes.SetOptionConstraintNumber(optionConstraintNumber);
127 scanOptDes.GetOptionConstraintNumber(optionConstraintNumber);
128 }
129
TestSetOptionConstraintRange(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)130 void TestSetOptionConstraintRange(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
131 {
132 ScanOptionDescriptor scanOptDes;
133 ScanRange optionConstraintRange;
134 scanOptDes.SetOptionConstraintRange(optionConstraintRange);
135 scanOptDes.GetOptionConstraintRange(optionConstraintRange);
136 std::string optionName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
137 scanOptDes.SetOptionName(optionName);
138 }
139
TestScanOptionDescriptor(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)140 void TestScanOptionDescriptor(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
141 {
142 ScanOptionDescriptor scanOptDesTmp;
143 uint32_t optionConstraintType = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
144 scanOptDesTmp.SetOptionConstraintType(optionConstraintType);
145 ScanOptionDescriptor scanOptDesBak(scanOptDesTmp);
146 ScanOptionDescriptor scanOptDesOpera = scanOptDesTmp;
147 scanOptDesOpera.Dump();
148 MessageParcel parcel;
149 scanOptDesOpera.Marshalling(parcel);
150 auto scanOptDesMarShall = ScanOptionDescriptor::Unmarshalling(parcel);
151 }
152
TestSetScanOptionValueType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)153 void TestSetScanOptionValueType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
154 {
155 ScanOptionValue scanOptVal;
156 int32_t valueType = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
157 scanOptVal.SetScanOptionValueType(static_cast<ScanOptionValueType>(valueType));
158 valueType = scanOptVal.GetScanOptionValueType();
159 }
160
TestSetValueSize(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)161 void TestSetValueSize(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
162 {
163 ScanOptionValue scanOptVal;
164 int32_t valueSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
165 scanOptVal.SetValueSize(valueSize);
166 valueSize = scanOptVal.GetValueSize();
167 }
168
TestSetNumValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)169 void TestSetNumValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
170 {
171 ScanOptionValue scanOptVal;
172 int32_t numValue = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
173 scanOptVal.SetNumValue(numValue);
174 numValue = scanOptVal.GetNumValue();
175 }
176
TestSetNumListValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)177 void TestSetNumListValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
178 {
179 ScanOptionValue scanOptVal;
180 int32_t vecSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
181 std::vector<int32_t> numListValue;
182 for (int i = 0; i < vecSize; i++) {
183 int32_t number = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
184 numListValue.emplace_back(number);
185 }
186 scanOptVal.SetNumListValue(numListValue);
187 scanOptVal.GetNumListValue(numListValue);
188 }
189
TestSetStrValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)190 void TestSetStrValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
191 {
192 ScanOptionValue scanOptVal;
193 std::string optionTitle = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
194 scanOptVal.SetStrValue(optionTitle);
195 optionTitle = scanOptVal.GetStrValue();
196 }
197
TestSetBoolValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)198 void TestSetBoolValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
199 {
200 ScanOptionValue scanOptVal;
201 bool boolValue = dataProvider->ConsumeBool();
202 scanOptVal.SetBoolValue(boolValue);
203 boolValue = scanOptVal.GetBoolValue();
204 }
205
TestScanOptionValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)206 void TestScanOptionValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
207 {
208 ScanOptionValue scanOptVal;
209 int32_t valueType = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
210 scanOptVal.SetScanOptionValueType(static_cast<ScanOptionValueType>(valueType));
211 ScanOptionValue scanOptValBak = scanOptVal;
212 scanOptValBak.Reset();
213 ScanOptionValue scanOptValOpera(scanOptValBak);
214 int32_t valueSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
215 scanOptValOpera.SetValueSize(valueSize);
216 MessageParcel parcel;
217 scanOptValOpera.Marshalling(parcel);
218 auto scanOptValMarShall = ScanOptionDescriptor::Unmarshalling(parcel);
219 scanOptValMarShall->Dump();
220 }
221
TestSetFormat(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)222 void TestSetFormat(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
223 {
224 ScanParameters scanPara;
225 int32_t format = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
226 scanPara.SetFormat(static_cast<ScanFrame>(format));
227 format = scanPara.GetFormat();
228 }
229
TestSetLastFrame(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)230 void TestSetLastFrame(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
231 {
232 ScanParameters scanPara;
233 bool lastFrame = dataProvider->ConsumeBool();
234 scanPara.SetLastFrame(lastFrame);
235 lastFrame = scanPara.GetLastFrame();
236 }
237
TestSetBytesPerLine(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)238 void TestSetBytesPerLine(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
239 {
240 ScanParameters scanPara;
241 int32_t bytesPerLine = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
242 scanPara.SetBytesPerLine(bytesPerLine);
243 bytesPerLine = scanPara.GetBytesPerLine();
244 }
245
TestSetPixelsPerLine(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)246 void TestSetPixelsPerLine(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
247 {
248 ScanParameters scanPara;
249 int32_t pixelsPerLine = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
250 scanPara.SetPixelsPerLine(pixelsPerLine);
251 pixelsPerLine = scanPara.GetPixelsPerLine();
252 }
253
TestSetLines(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)254 void TestSetLines(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
255 {
256 ScanParameters scanPara;
257 int32_t lines = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
258 scanPara.SetLines(lines);
259 lines = scanPara.GetLines();
260 }
261
TestSetDepth(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)262 void TestSetDepth(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
263 {
264 ScanParameters scanPara;
265 int32_t depth = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
266 scanPara.SetDepth(depth);
267 depth = scanPara.GetDepth();
268 }
269
TestScanParameters(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)270 void TestScanParameters(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
271 {
272 ScanParameters scanPara;
273 int32_t lines = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
274 scanPara.SetLines(lines);
275 ScanParameters scanParaTmp(scanPara);
276 ScanParameters scanParaBak = scanParaTmp;
277 scanParaBak.Dump();
278 MessageParcel parcel;
279 scanParaBak.Marshalling(parcel);
280 auto scanParaBakMarShall = ScanParameters::Unmarshalling(parcel);
281 }
282
TestSetScanProgress(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)283 void TestSetScanProgress(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
284 {
285 ScanProgress scanProg;
286 int32_t progress = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
287 scanProg.SetScanProgress(progress);
288 progress = scanProg.GetScanProgress();
289 }
290
TestSetScanPictureFd(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)291 void TestSetScanPictureFd(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
292 {
293 ScanProgress scanProg;
294 int32_t fd = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
295 scanProg.SetScanPictureFd(fd);
296 fd = scanProg.GetScanPictureFd();
297 }
298
TestSetIsFinal(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)299 void TestSetIsFinal(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
300 {
301 ScanProgress scanProg;
302 bool isFinal = dataProvider->ConsumeBool();
303 scanProg.SetIsFinal(isFinal);
304 isFinal = scanProg.GetIsFinal();
305 }
306
TestSetPictureId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)307 void TestSetPictureId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
308 {
309 ScanProgress scanProg;
310 int32_t pictureId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
311 scanProg.SetPictureId(pictureId);
312 pictureId = scanProg.GetPictureId();
313 }
314
TestSetTaskCode(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)315 void TestSetTaskCode(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
316 {
317 ScanProgress scanProg;
318 int32_t taskCode = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
319 scanProg.SetTaskCode(static_cast<ScanErrorCode>(taskCode));
320 taskCode = scanProg.GetTaskCode();
321 }
322
TestScanProgress(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)323 void TestScanProgress(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
324 {
325 ScanProgress scanProg;
326 int32_t taskCode = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
327 scanProg.SetTaskCode(static_cast<ScanErrorCode>(taskCode));
328 scanProg.Dump();
329 taskCode = scanProg.GetTaskCode();
330 ScanProgress scanProgTmp(scanProg);
331 ScanProgress scanProgBak = scanProgTmp;
332 MessageParcel parcel;
333 scanProgBak.Marshalling(parcel);
334 auto scanOptValMarShall = ScanProgress::Unmarshalling(parcel);
335 }
336
TestTCPSetDeviceName(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)337 void TestTCPSetDeviceName(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
338 {
339 ScanDeviceInfoTCP scanDevInfoTcp;
340 std::string deviceName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
341 scanDevInfoTcp.SetDeviceName(deviceName);
342 deviceName = scanDevInfoTcp.GetDeviceName();
343 }
344
TestTCPSetUuid(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)345 void TestTCPSetUuid(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
346 {
347 ScanDeviceInfoTCP scanDevInfoTcp;
348 std::string uuid = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
349 scanDevInfoTcp.SetUuid(uuid);
350 uuid = scanDevInfoTcp.GetUuid();
351 }
352
TestTCPSetModel(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)353 void TestTCPSetModel(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
354 {
355 ScanDeviceInfoTCP scanDevInfoTcp;
356 std::string model = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
357 scanDevInfoTcp.SetModel(model);
358 model = scanDevInfoTcp.GetModel();
359 }
360
TestTCPSetManufacturer(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)361 void TestTCPSetManufacturer(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
362 {
363 ScanDeviceInfoTCP scanDevInfoTcp;
364 std::string manufacturer = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
365 scanDevInfoTcp.SetManufacturer(manufacturer);
366 manufacturer = scanDevInfoTcp.GetManufacturer();
367 }
368
TestTCPSetDeviceType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)369 void TestTCPSetDeviceType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
370 {
371 ScanDeviceInfoTCP scanDevInfoTcp;
372 std::string deviceType = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
373 scanDevInfoTcp.SetDeviceType(deviceType);
374 deviceType = scanDevInfoTcp.GetDeviceType();
375 }
376
TestTCPSetPort(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)377 void TestTCPSetPort(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
378 {
379 ScanDeviceInfoTCP scanDevInfoTcp;
380 std::string port = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
381 scanDevInfoTcp.SetPort(port);
382 port = scanDevInfoTcp.GetPort();
383 }
384
385
TestTCPSetAddr(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)386 void TestTCPSetAddr(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
387 {
388 ScanDeviceInfoTCP scanDevInfoTcp;
389 std::string addr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
390 scanDevInfoTcp.SetAddr(addr);
391 addr = scanDevInfoTcp.GetAddr();
392 }
393
TestTCPSetButton(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)394 void TestTCPSetButton(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
395 {
396 ScanDeviceInfoTCP scanDevInfoTcp;
397 std::string button = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
398 scanDevInfoTcp.SetButton(button);
399 button = scanDevInfoTcp.GetButton();
400 }
401
TestTCPSetFeeder(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)402 void TestTCPSetFeeder(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
403 {
404 ScanDeviceInfoTCP scanDevInfoTcp;
405 std::string feeder = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
406 scanDevInfoTcp.SetFeeder(feeder);
407 feeder = scanDevInfoTcp.GetFeeder();
408 }
409
TestTCPSetDeviceState(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)410 void TestTCPSetDeviceState(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
411 {
412 ScanDeviceInfoTCP scanDevInfoTcp;
413 uint32_t deviceState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
414 scanDevInfoTcp.SetDeviceState(deviceState);
415 deviceState = scanDevInfoTcp.GetDeviceState();
416 }
417
TestUSBSetDeviceId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)418 void TestUSBSetDeviceId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
419 {
420 ScanDeviceInfo deviceInfo;
421 std::string deviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
422 deviceInfo.SetDeviceId(deviceId);
423 deviceId = deviceInfo.GetDeviceId();
424 }
425
TestUSBSetManufacturer(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)426 void TestUSBSetManufacturer(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
427 {
428 ScanDeviceInfo deviceInfo;
429 std::string manufacturer = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
430 deviceInfo.SetManufacturer(manufacturer);
431 manufacturer = deviceInfo.GetManufacturer();
432 }
433
TestUSBSetModel(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)434 void TestUSBSetModel(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
435 {
436 ScanDeviceInfo deviceInfo;
437 std::string model = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
438 deviceInfo.SetModel(model);
439 model = deviceInfo.GetModel();
440 }
441
TestUSBSetDeviceType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)442 void TestUSBSetDeviceType(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
443 {
444 ScanDeviceInfo deviceInfo;
445 std::string deviceType = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
446 deviceInfo.SetDeviceType(deviceType);
447 deviceType = deviceInfo.GetDeviceType();
448 }
449
TestUSBSetDeviceState(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)450 void TestUSBSetDeviceState(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
451 {
452 ScanDeviceInfo deviceInfo;
453 uint32_t deviceState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
454 deviceInfo.SetDeviceState(deviceState);
455 deviceState = deviceInfo.GetDeviceState();
456 }
457
TestUSBSetDiscoverMode(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)458 void TestUSBSetDiscoverMode(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
459 {
460 ScanDeviceInfo deviceInfo;
461 std::string discoverMode = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
462 deviceInfo.SetDiscoverMode(discoverMode);
463 discoverMode = deviceInfo.GetDiscoverMode();
464 }
465
TestUSBSetSerialNumber(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)466 void TestUSBSetSerialNumber(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
467 {
468 ScanDeviceInfo deviceInfo;
469 std::string serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
470 deviceInfo.SetSerialNumber(serialNumber);
471 serialNumber = deviceInfo.GetSerialNumber();
472 }
473
TestSetMinValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)474 void TestSetMinValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
475 {
476 ScanRange range;
477 int32_t minValue = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
478 range.SetMinValue(minValue);
479 minValue = range.GetMinValue();
480 }
481
TestSetMaxValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)482 void TestSetMaxValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
483 {
484 ScanRange range;
485 int32_t maxValue = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
486 range.SetMaxValue(maxValue);
487 maxValue = range.GetMaxValue();
488 }
489
TestSetQuantValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)490 void TestSetQuantValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
491 {
492 ScanRange range;
493 int32_t quantValue = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
494 range.SetQuantValue(quantValue);
495 quantValue = range.GetQuantValue();
496 }
497
TestScanRange(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)498 void TestScanRange(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
499 {
500 ScanRange range;
501 range.Reset();
502 int32_t maxValue = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
503 range.SetMaxValue(maxValue);
504 ScanRange rangeBak(range);
505 MessageParcel parcel;
506 range.Marshalling(parcel);
507 auto rangeMarshall = ScanRange::Unmarshalling(parcel);
508 }
509
TestDeviceInfo(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)510 void TestDeviceInfo(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
511 {
512 ScanDeviceInfoTCP infoTcp;
513 uint32_t deviceState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
514 infoTcp.SetDeviceState(deviceState);
515 ScanDeviceInfoTCP infoTcpTmp(infoTcp);
516 ScanDeviceInfoTCP infoTcpBak(infoTcpTmp);
517 MessageParcel parcel;
518 infoTcpBak.Marshalling(parcel);
519 auto infoTcpMarshall = ScanDeviceInfoTCP::Unmarshalling(parcel);
520
521 ScanDeviceInfo info;
522 info.SetDeviceState(deviceState);
523 ScanDeviceInfo infoTmp(info);
524 ScanDeviceInfo infoBak(infoTmp);
525 infoBak.Marshalling(parcel);
526 auto infoMarshall = ScanDeviceInfo::Unmarshalling(parcel);
527 }
528
TestScanOptDesNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)529 void TestScanOptDesNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
530 {
531 napi_env env = nullptr;
532 ScanOptionDescriptor info;
533 uint32_t optionUnit = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
534 info.SetOptionUnit(optionUnit);
535 ScanOptionDescriptorHelper::MakeJsObject(env, info);
536 napi_value jsValue = nullptr;
537 ScanOptionDescriptorHelper::BuildFromJs(env, jsValue);
538 }
539
TestScanOptValNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)540 void TestScanOptValNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
541 {
542 napi_env env = nullptr;
543 ScanOptionValue info;
544 int32_t valueType = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
545 info.SetScanOptionValueType(static_cast<ScanOptionValueType>(valueType));
546 ScanOptionValueHelper::MakeJsObject(env, info);
547 napi_value jsValue = nullptr;
548 ScanOptionValueHelper::BuildFromJs(env, jsValue);
549 }
550
TestScanParaNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)551 void TestScanParaNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
552 {
553 napi_env env = nullptr;
554 ScanParameters info;
555 int32_t format = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
556 info.SetFormat(static_cast<ScanFrame>(format));
557 ScanParametersHelper::MakeJsObject(env, info);
558 napi_value jsValue = nullptr;
559 ScanParametersHelper::BuildFromJs(env, jsValue);
560 }
561
TestScanProgNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)562 void TestScanProgNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
563 {
564 napi_env env = nullptr;
565 ScanProgress info;
566 int32_t progress = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
567 info.SetScanProgress(progress);
568 ScanProgressHelper::MakeJsObject(env, info);
569 }
570
TestScanRangeNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)571 void TestScanRangeNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
572 {
573 napi_env env = nullptr;
574 ScanRange info;
575 int32_t maxValue = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
576 info.SetMaxValue(maxValue);
577 ScanRangeHelper::MakeJsObject(env, info);
578 napi_value jsValue = nullptr;
579 ScanRangeHelper::BuildFromJs(env, jsValue);
580 }
581
TestScannerInfoNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)582 void TestScannerInfoNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
583 {
584 napi_env env = nullptr;
585 ScanDeviceInfo info;
586 std::string deviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
587 info.SetDeviceId(deviceId);
588 ScannerInfoHelper::MakeJsObject(env, info);
589 }
590
TestScannerInfoTCPNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)591 void TestScannerInfoTCPNapiInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
592 {
593 napi_env env = nullptr;
594 ScanDeviceInfoTCP info;
595 uint32_t deviceState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
596 info.SetDeviceState(deviceState);
597 ScannerInfoHelperTCP::MakeJsObject(env, info);
598 }
599
TestGetExtensionIdInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)600 void TestGetExtensionIdInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
601 {
602 std::string globalId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
603 NapiScanUtils::GetExtensionId(globalId);
604 }
605
TestGetGlobalIdInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)606 void TestGetGlobalIdInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
607 {
608 std::string globalId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
609 std::string localId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
610 NapiScanUtils::GetGlobalId(globalId, localId);
611 }
612
TestGetLocalIdInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)613 void TestGetLocalIdInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
614 {
615 std::string globalId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
616 std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
617 NapiScanUtils::GetLocalId(globalId, extensionId);
618 }
619
TestEncodeExtensionCidInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)620 void TestEncodeExtensionCidInterface(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
621 {
622 std::string globalId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
623 uint32_t callbackId = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
624 NapiScanUtils::EncodeExtensionCid(globalId, callbackId);
625 }
626
TestDecodeExtensionCid(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)627 void TestDecodeExtensionCid(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
628 {
629 std::string cid = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
630 std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
631 uint32_t callbackId = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
632 NapiScanUtils::DecodeExtensionCid(cid, extensionId, callbackId);
633 }
634
TestGetTaskEventId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)635 void TestGetTaskEventId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
636 {
637 std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
638 std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
639 NapiScanUtils::GetTaskEventId(taskId, type);
640 }
641
TestOpenFile(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)642 void TestOpenFile(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
643 {
644 std::string filePath = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
645 NapiScanUtils::OpenFile(filePath);
646 }
647
TestIsPathValid(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)648 void TestIsPathValid(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
649 {
650 std::string filePath = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
651 NapiScanUtils::IsPathValid(filePath);
652 }
653
ScanOptionDescriptorFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)654 void ScanOptionDescriptorFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
655 {
656 TestSetOptionName(data, size, dataProvider);
657 TestSetOptionTitle(data, size, dataProvider);
658 TestSetOptionDesc(data, size, dataProvider);
659 TestSetOptionType(data, size, dataProvider);
660 TestSetOptionUnit(data, size, dataProvider);
661 TestSetOptionSize(data, size, dataProvider);
662 TestSetOptionCap(data, size, dataProvider);
663 TestSetOptionConstraintType(data, size, dataProvider);
664 TestSetOptionConstraintString(data, size, dataProvider);
665 TestSetOptionConstraintNumber(data, size, dataProvider);
666 TestSetOptionConstraintRange(data, size, dataProvider);
667 TestScanOptionDescriptor(data, size, dataProvider);
668 }
669
ScanOptionValueFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)670 void ScanOptionValueFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
671 {
672 TestSetScanOptionValueType(data, size, dataProvider);
673 TestSetValueSize(data, size, dataProvider);
674 TestSetNumValue(data, size, dataProvider);
675 TestSetNumListValue(data, size, dataProvider);
676 TestSetStrValue(data, size, dataProvider);
677 TestSetBoolValue(data, size, dataProvider);
678 TestScanOptionValue(data, size, dataProvider);
679 }
680
ScanParametersFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)681 void ScanParametersFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
682 {
683 TestSetFormat(data, size, dataProvider);
684 TestSetLastFrame(data, size, dataProvider);
685 TestSetBytesPerLine(data, size, dataProvider);
686 TestSetPixelsPerLine(data, size, dataProvider);
687 TestSetLines(data, size, dataProvider);
688 TestSetDepth(data, size, dataProvider);
689 TestScanParameters(data, size, dataProvider);
690 }
691
ScanDeviceInfoFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)692 void ScanDeviceInfoFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
693 {
694 TestSetScanProgress(data, size, dataProvider);
695 TestSetScanPictureFd(data, size, dataProvider);
696 TestSetIsFinal(data, size, dataProvider);
697 TestSetPictureId(data, size, dataProvider);
698 TestSetTaskCode(data, size, dataProvider);
699 TestScanProgress(data, size, dataProvider);
700 }
701
ScannerInfoFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)702 void ScannerInfoFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
703 {
704 TestTCPSetDeviceName(data, size, dataProvider);
705 TestTCPSetUuid(data, size, dataProvider);
706 TestTCPSetModel(data, size, dataProvider);
707 TestTCPSetManufacturer(data, size, dataProvider);
708 TestTCPSetDeviceType(data, size, dataProvider);
709 TestTCPSetPort(data, size, dataProvider);
710 TestTCPSetAddr(data, size, dataProvider);
711 TestTCPSetButton(data, size, dataProvider);
712 TestTCPSetFeeder(data, size, dataProvider);
713 TestTCPSetDeviceState(data, size, dataProvider);
714 TestUSBSetDeviceId(data, size, dataProvider);
715 TestUSBSetManufacturer(data, size, dataProvider);
716 TestUSBSetModel(data, size, dataProvider);
717 TestUSBSetDeviceType(data, size, dataProvider);
718 TestUSBSetDeviceState(data, size, dataProvider);
719 TestUSBSetDiscoverMode(data, size, dataProvider);
720 TestUSBSetSerialNumber(data, size, dataProvider);
721 TestDeviceInfo(data, size, dataProvider);
722 }
723
ScanRangeFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)724 void ScanRangeFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
725 {
726 TestSetMinValue(data, size, dataProvider);
727 TestSetMaxValue(data, size, dataProvider);
728 TestSetQuantValue(data, size, dataProvider);
729 TestScanRange(data, size, dataProvider);
730 }
731
ScanOptionDescriptorHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)732 void ScanOptionDescriptorHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
733 {
734 TestScanOptDesNapiInterface(data, size, dataProvider);
735 }
736
ScanOptionValueHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)737 void ScanOptionValueHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
738 {
739 TestScanOptValNapiInterface(data, size, dataProvider);
740 }
741
ScanParametersHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)742 void ScanParametersHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
743 {
744 TestScanParaNapiInterface(data, size, dataProvider);
745 }
746
ScanProgressHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)747 void ScanProgressHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
748 {
749 TestScanProgNapiInterface(data, size, dataProvider);
750 }
751
ScanRangeHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)752 void ScanRangeHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
753 {
754 TestScanRangeNapiInterface(data, size, dataProvider);
755 }
756
ScannerInfoHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)757 void ScannerInfoHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
758 {
759 TestScannerInfoNapiInterface(data, size, dataProvider);
760 TestScannerInfoTCPNapiInterface(data, size, dataProvider);
761 }
762
NapiScanUtilsFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)763 void NapiScanUtilsFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
764 {
765 TestGetExtensionIdInterface(data, size, dataProvider);
766 TestGetGlobalIdInterface(data, size, dataProvider);
767 TestGetLocalIdInterface(data, size, dataProvider);
768 TestEncodeExtensionCidInterface(data, size, dataProvider);
769 TestDecodeExtensionCid(data, size, dataProvider);
770 TestGetTaskEventId(data, size, dataProvider);
771 TestOpenFile(data, size, dataProvider);
772 TestIsPathValid(data, size, dataProvider);
773 }
774
775 }
776 }
777
778 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)779 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
780 {
781 if (data == nullptr) {
782 return 0;
783 }
784
785 if (size < OHOS::Scan::U32_AT_SIZE || size > OHOS::Scan::FOO_MAX_LEN) {
786 return 0;
787 }
788 FuzzedDataProvider dataProvider(data, size);
789 OHOS::Scan::ScanOptionDescriptorFuzzTest(data, size, &dataProvider);
790 OHOS::Scan::ScanOptionValueFuzzTest(data, size, &dataProvider);
791 OHOS::Scan::ScanParametersFuzzTest(data, size, &dataProvider);
792 OHOS::Scan::ScanDeviceInfoFuzzTest(data, size, &dataProvider);
793 OHOS::Scan::ScannerInfoFuzzTest(data, size, &dataProvider);
794 OHOS::Scan::ScanRangeFuzzTest(data, size, &dataProvider);
795 OHOS::Scan::ScanOptionDescriptorHelperFuzzTest(data, size, &dataProvider);
796 OHOS::Scan::ScanOptionValueHelperFuzzTest(data, size, &dataProvider);
797 OHOS::Scan::ScanParametersHelperFuzzTest(data, size, &dataProvider);
798 OHOS::Scan::ScanProgressHelperFuzzTest(data, size, &dataProvider);
799 OHOS::Scan::ScanRangeHelperFuzzTest(data, size, &dataProvider);
800 OHOS::Scan::ScannerInfoHelperFuzzTest(data, size, &dataProvider);
801 OHOS::Scan::NapiScanUtilsFuzzTest(data, size, &dataProvider);
802 return 0;
803 }
804
805