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 #define private public
17 #define protected public
18 #include "fuzzer/FuzzedDataProvider.h"
19 #include "scanserviceability_fuzzer.h"
20 #include "scan_service_ability.h"
21 #include "scan_callback_proxy.h"
22 #include "scan_service_ability_mock.h"
23
24 namespace OHOS {
25 namespace Scan {
26 constexpr size_t FOO_MAX_LEN = 1024;
27 constexpr size_t U32_AT_SIZE = 4;
28 constexpr uint8_t MAX_STRING_LENGTH = 255;
29 constexpr int MAX_SET_NUMBER = 100;
30
TestInitScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)31 void TestInitScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
32 {
33 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
34 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
35 ScanServiceAbility::GetInstance()->ExitScan();
36 }
37
TestGetScannerList(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)38 void TestGetScannerList(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
39 {
40 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
41 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
42 ScanServiceAbility::GetInstance()->GetScannerList();
43 }
44
TestStopDiscover(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)45 void TestStopDiscover(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
46 {
47 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
48 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
49 ScanServiceAbility::GetInstance()->StopDiscover();
50 }
51
TestOpenScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)52 void TestOpenScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
53 {
54 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
55 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
56 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
57 ScanServiceAbility::GetInstance()->OpenScanner(scannerId);
58 }
59
TestCloseScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)60 void TestCloseScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
61 {
62 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
63 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
64 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
65 ScanServiceAbility::GetInstance()->OpenScanner(scannerId);
66 ScanServiceAbility::GetInstance()->CloseScanner(scannerId);
67 }
68
TestGetScanOptionDesc(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)69 void TestGetScanOptionDesc(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
70 {
71 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
72 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
73 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
74 int32_t optionIndex = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
75 ScanOptionDescriptor desc;
76 ScanServiceAbility::GetInstance()->GetScanOptionDesc(scannerId, optionIndex, desc);
77 }
78
TestStartScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)79 void TestStartScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
80 {
81 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
82 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
83 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
84 bool batchMode = dataProvider->ConsumeBool();
85 ScanServiceAbility::GetInstance()->StartScan(scannerId, batchMode);
86 }
87
TestGetSingleFrameFD(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)88 void TestGetSingleFrameFD(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
89 {
90 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
91 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
92 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
93 uint32_t frameSize = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
94 uint32_t fd = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
95 ScanServiceAbility::GetInstance()->GetSingleFrameFD(scannerId, frameSize, fd);
96 }
97
TestCancelScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)98 void TestCancelScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
99 {
100 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
101 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
102 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
103 ScanServiceAbility::GetInstance()->CancelScan(scannerId);
104 }
105
TestSetScanIOMode(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)106 void TestSetScanIOMode(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
107 {
108 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
109 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
110 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
111 bool isNonBlocking = dataProvider->ConsumeBool();
112 ScanServiceAbility::GetInstance()->SetScanIOMode(scannerId, isNonBlocking);
113 }
114
TestGetScanSelectFd(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)115 void TestGetScanSelectFd(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
116 {
117 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
118 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
119 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
120 int32_t fd = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
121 ScanServiceAbility::GetInstance()->GetScanSelectFd(scannerId, fd);
122 }
123
TestOn(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)124 void TestOn(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
125 {
126 std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
127 std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
128 sptr<IRemoteObject> impl;
129 ScanCallbackProxy scanCallbackProxy(impl);
130 sptr<IScanCallback> listener = iface_cast<IScanCallback>(impl);
131 ScanServiceAbility::registeredListeners_[type] = listener;
132 ScanServiceAbility::GetInstance()->On(taskId, type, listener);
133 ScanServiceAbility::registeredListeners_.clear();
134 }
135
TestOff(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)136 void TestOff(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
137 {
138 std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
139 std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
140 sptr<IRemoteObject> impl;
141 ScanCallbackProxy scanCallbackProxy(impl);
142 sptr<IScanCallback> listener = iface_cast<IScanCallback>(impl);
143 ScanServiceAbility::registeredListeners_[type] = listener;
144 ScanServiceAbility::GetInstance()->Off(taskId, type);
145 }
146
TestGetScannerState(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)147 void TestGetScannerState(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
148 {
149 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
150 ScanServiceAbility::GetInstance()->InitScan(scanVersion);
151 int32_t scannerState = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
152 ScanServiceAbility::GetInstance()->GetScannerState(scannerState);
153 }
154
TestOnStartScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)155 void TestOnStartScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
156 {
157 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
158 bool batchMode = dataProvider->ConsumeBool();
159 auto scanSaPtr = ScanServiceAbility::GetInstance();
160 if (scanSaPtr == nullptr) {
161 return;
162 }
163 scanSaPtr->OnStartScan(scannerId, batchMode);
164 int32_t userId = scanSaPtr->GetCurrentUserId();
165 scanSaPtr->ObtainUserCacheDirectory(userId);
166 userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
167 scanSaPtr->ObtainUserCacheDirectory(userId);
168 constexpr int32_t DEFAULT_USERID = 100;
169 userId = DEFAULT_USERID;
170 scanSaPtr->ObtainUserCacheDirectory(userId);
171 }
172
TestSendDeviceInfoTCP(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)173 void TestSendDeviceInfoTCP(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
174 {
175 ScanDeviceInfoTCP info;
176 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
177 ScanServiceAbility::GetInstance()->SendDeviceInfoTCP(info, event);
178 }
179
TestSendDeviceInfo(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)180 void TestSendDeviceInfo(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
181 {
182 ScanDeviceInfo info;
183 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
184 ScanServiceAbility::GetInstance()->SendDeviceInfo(info, event);
185 }
186
TestSendDeviceInfoSync(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)187 void TestSendDeviceInfoSync(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
188 {
189 ScanDeviceInfoSync info;
190 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
191 ScanServiceAbility::GetInstance()->SendDeviceInfoSync(info, event);
192 }
193
TestDisConnectUsbScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)194 void TestDisConnectUsbScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
195 {
196 std::string serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
197 std::string newDeviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
198 ScanServiceAbility::GetInstance()->DisConnectUsbScanner(serialNumber, newDeviceId);
199 }
200
TestUpdateUsbScannerId(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)201 void TestUpdateUsbScannerId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
202 {
203 std::string discoverMode = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
204 ScanDeviceInfoSync usbSyncInfo;
205 usbSyncInfo.discoverMode = discoverMode;
206 ScanServiceAbility::GetInstance()->UpdateScannerId(usbSyncInfo);
207 usbSyncInfo.discoverMode = "USB";
208 ScanServiceAbility::GetInstance()->UpdateScannerId(usbSyncInfo);
209 usbSyncInfo.discoverMode = "TCP";
210 ScanServiceAbility::GetInstance()->UpdateScannerId(usbSyncInfo);
211 }
212
TestSendInitEvent(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)213 void TestSendInitEvent(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
214 {
215 int32_t scanVersion = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
216 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
217 ScanServiceAbility::GetInstance()->SendInitEvent(scanVersion, event);
218 }
219
TestSendDeviceSearchEnd(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)220 void TestSendDeviceSearchEnd(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
221 {
222 std::string message = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
223 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
224 ScanServiceAbility::GetInstance()->SendDeviceSearchEnd(message, event);
225 }
226
TestSetScannerSerialNumber(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)227 void TestSetScannerSerialNumber(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
228 {
229 ScanDeviceInfo tcpInfo;
230 tcpInfo.deviceId = "pantum6500:tcp 192.168.223.1 9200-M6700DW";
231 std::string ip = "192.168.223.1";
232 ScanDeviceInfoTCP scanDeviceInfoTCP;
233 scanDeviceInfoTCP.deviceName = "Pantum 6666 54QWER";
234 ScanMdnsService::InsertIpToScannerInfo(ip, scanDeviceInfoTCP);
235 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(tcpInfo);
236
237 tcpInfo.deviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
238 ip = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
239 scanDeviceInfoTCP.deviceName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
240 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(tcpInfo);
241
242 ScanDeviceInfo usbInfo;
243 usbInfo.deviceId = "pantum6500:libusb:002:003";
244 ScanServiceAbility::usbSnMap["2-3"] = "QWERTY";
245 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(usbInfo);
246
247 usbInfo.deviceId = "pantum6500:libusb:002:004";
248 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(usbInfo);
249 usbInfo.deviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
250 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(usbInfo);
251 }
252
TestReInitScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)253 void TestReInitScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
254 {
255 ScanServiceAbility::GetInstance()->ServiceInit();
256 ScanServiceAbility::GetInstance()->InitServiceHandler();
257 ScanServiceAbility::GetInstance()->OnStart();
258 ScanServiceAbility::GetInstance()->OnStop();
259 ScanServiceAbility::GetInstance()->ManualStart();
260 ScanServiceAbility::GetInstance()->ReInitScan();
261 ScanServiceAbility::GetInstance()->SaneGetScanner();
262 }
263
TestCheckPermission(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)264 void TestCheckPermission(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
265 {
266 std::string permissionName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
267 ScanServiceAbility::GetInstance()->CheckPermission(permissionName);
268 }
269
TestGeneratePictureBatch(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)270 void TestGeneratePictureBatch(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
271 {
272 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
273 ScanServiceAbility::GetInstance()->GeneratePictureSingle(scannerId);
274 }
275
TestAddFoundScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)276 void TestAddFoundScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
277 {
278 ScanDeviceInfo info;
279 info.serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
280 ScanServiceAbility::GetInstance()->AddFoundScanner(info);
281 }
282
TestSendDeviceList(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)283 void TestSendDeviceList(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
284 {
285 ScanDeviceInfo infoItem;
286 std::vector<ScanDeviceInfo> info;
287 info.push_back(infoItem);
288 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
289 ScanServiceAbility::GetInstance()->SendDeviceList(info, event);
290 }
291
TestAddScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)292 void TestAddScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
293 {
294 std::string serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
295 std::string discoverMode = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
296 ScanServiceAbility::GetInstance()->AddScanner(serialNumber, discoverMode);
297 }
298
TestUpdateScannerName(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)299 void TestUpdateScannerName(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
300 {
301 std::string serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
302 std::string discoverMode = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
303 std::string deviceName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
304 ScanServiceAbility::GetInstance()->UpdateScannerName(serialNumber, discoverMode, deviceName);
305 }
306
TestCleanScanTask(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)307 void TestCleanScanTask(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
308 {
309 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
310 ScanServiceAbility::GetInstance()->CleanScanTask(scannerId);
311 }
312
TestGetAddedScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)313 void TestGetAddedScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
314 {
315 ScanDeviceInfo addedScanner;
316 std::string newDeviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
317 addedScanner.SetDeviceId(newDeviceId);
318 std::vector<ScanDeviceInfo> allAddedScanner;
319 allAddedScanner.push_back(addedScanner);
320 ScanServiceAbility::GetInstance()->GetAddedScanner(allAddedScanner);
321 }
322
TestNotPublicFunction(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)323 void TestNotPublicFunction(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
324 {
325 if (dataProvider == nullptr) {
326 return;
327 }
328 OHOS::Scan::TestReInitScan(data, size, dataProvider);
329 OHOS::Scan::TestCheckPermission(data, size, dataProvider);
330 OHOS::Scan::TestGeneratePictureBatch(data, size, dataProvider);
331 OHOS::Scan::TestAddFoundScanner(data, size, dataProvider);
332 OHOS::Scan::TestSendDeviceList(data, size, dataProvider);
333 OHOS::Scan::TestAddScanner(data, size, dataProvider);
334 OHOS::Scan::TestUpdateScannerName(data, size, dataProvider);
335 OHOS::Scan::TestCleanScanTask(data, size, dataProvider);
336 OHOS::Scan::TestGetAddedScanner(data, size, dataProvider);
337 }
338
TestCleanUpAfterScan(FuzzedDataProvider * dataProvider)339 void TestCleanUpAfterScan(FuzzedDataProvider* dataProvider)
340 {
341 if (dataProvider == nullptr) {
342 return;
343 }
344 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
345 ScanServiceAbility::GetInstance()->RestartScan(scannerId);
346 int32_t scanStatus = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
347 ScanServiceAbility::GetInstance()->CleanUpAfterScan(scanStatus);
348 }
349
350 }
351 }
352
353 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)354 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
355 {
356 if (data == nullptr) {
357 return 0;
358 }
359
360 if (size < OHOS::Scan::U32_AT_SIZE || size > OHOS::Scan::FOO_MAX_LEN) {
361 return 0;
362 }
363 FuzzedDataProvider dataProvider(data, size);
364 OHOS::Scan::ScanServiceAbilityMock::MockPermission();
365 OHOS::Scan::TestInitScan(data, size, &dataProvider);
366 OHOS::Scan::TestGetScannerList(data, size, &dataProvider);
367 OHOS::Scan::TestStopDiscover(data, size, &dataProvider);
368 OHOS::Scan::TestOpenScanner(data, size, &dataProvider);
369 OHOS::Scan::TestCloseScanner(data, size, &dataProvider);
370 OHOS::Scan::TestGetScanOptionDesc(data, size, &dataProvider);
371 OHOS::Scan::TestStartScan(data, size, &dataProvider);
372 OHOS::Scan::TestGetSingleFrameFD(data, size, &dataProvider);
373 OHOS::Scan::TestCancelScan(data, size, &dataProvider);
374 OHOS::Scan::TestSetScanIOMode(data, size, &dataProvider);
375 OHOS::Scan::TestGetScanSelectFd(data, size, &dataProvider);
376 OHOS::Scan::TestOn(data, size, &dataProvider);
377 OHOS::Scan::TestOff(data, size, &dataProvider);
378 OHOS::Scan::TestGetScannerState(data, size, &dataProvider);
379 OHOS::Scan::TestOnStartScan(data, size, &dataProvider);
380 OHOS::Scan::TestSendDeviceInfoTCP(data, size, &dataProvider);
381 OHOS::Scan::TestSendDeviceInfo(data, size, &dataProvider);
382 OHOS::Scan::TestSendDeviceInfoSync(data, size, &dataProvider);
383 OHOS::Scan::TestDisConnectUsbScanner(data, size, &dataProvider);
384 OHOS::Scan::TestUpdateUsbScannerId(data, size, &dataProvider);
385 OHOS::Scan::TestSendInitEvent(data, size, &dataProvider);
386 OHOS::Scan::TestSendDeviceSearchEnd(data, size, &dataProvider);
387 OHOS::Scan::TestSetScannerSerialNumber(data, size, &dataProvider);
388 OHOS::Scan::TestNotPublicFunction(data, size, &dataProvider);
389 OHOS::Scan::TestCleanUpAfterScan(&dataProvider);
390 return 0;
391 }