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
33namespace OHOS {
34namespace Scan {
35constexpr uint8_t MAX_STRING_LENGTH = 255;
36constexpr int MAX_SET_NUMBER = 100;
37constexpr size_t FOO_MAX_LEN = 1024;
38constexpr size_t U32_AT_SIZE = 4;
39
40void 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
48void 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
56void 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
64void 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
72void 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
80void 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
88void 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
96void 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
104void 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
117void 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
130void 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
140void 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
153void 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
161void 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
169void 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
177void 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
190void 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
198void 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
206void 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
222void 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
230void 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
238void 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
246void 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
254void 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
262void 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
270void 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
283void 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
291void 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
299void 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
307void 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
315void 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
323void 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
337void 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
345void 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
353void 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
361void 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
369void 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
377void 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
386void 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
394void 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
402void 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
410void 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
418void 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
426void 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
434void 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
442void 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
450void 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
458void 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
466void 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
474void 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
482void 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
490void 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
498void 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
510void 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
529void 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
540void 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
551void 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
562void 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
571void 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
582void 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
591void 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
600void 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
606void 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
613void 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
620void 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
627void 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
635void 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
642void 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
648void 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
654void 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
670void 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
681void 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
692void 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
702void 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
724void 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
732void ScanOptionDescriptorHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
733{
734    TestScanOptDesNapiInterface(data, size, dataProvider);
735}
736
737void ScanOptionValueHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
738{
739    TestScanOptValNapiInterface(data, size, dataProvider);
740}
741
742void ScanParametersHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
743{
744    TestScanParaNapiInterface(data, size, dataProvider);
745}
746
747void ScanProgressHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
748{
749    TestScanProgNapiInterface(data, size, dataProvider);
750}
751
752void ScanRangeHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
753{
754    TestScanRangeNapiInterface(data, size, dataProvider);
755}
756
757void ScannerInfoHelperFuzzTest(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
758{
759    TestScannerInfoNapiInterface(data, size, dataProvider);
760    TestScannerInfoTCPNapiInterface(data, size, dataProvider);
761}
762
763void 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 */
779extern "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