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