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#define private public
16#define protected public
17#include "printserviceability_fuzzer.h"
18#include "fuzzer/FuzzedDataProvider.h"
19#include "print_constant.h"
20#include "printer_capability.h"
21#include "print_log.h"
22#include "print_service_ability.h"
23#include "print_service_ability_mock_permission.h"
24#include "print_callback.h"
25#include "iprint_adapter_inner.h"
26
27namespace OHOS {
28namespace Print {
29constexpr uint8_t MAX_STRING_LENGTH = 20;
30constexpr int MAX_SET_NUMBER = 128;
31constexpr size_t U32_AT_SIZE = 4;
32static constexpr const char *JOB_OPTIONS =
33    "{\"jobName\":\"xx\",\"jobNum\":1,\"mediaType\":\"stationery\",\"documentCategory\":0,\"printQuality\":\"4\","
34    "\"printerName\":\"testId\",\"printerUri\":\"ipp://192.168.0.1:111/ipp/print\","
35    "\"documentFormat\":\"application/pdf\",\"files\":[\"/data/1.pdf\"]}";
36static const std::string DEFAULT_PRINTERID = "testId";
37
38void TestStartPrint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
39{
40    PrintServiceAbilityMockPermission::MockPermission();
41    PrintServiceAbility::GetInstance()->OnStart();
42    PrintServiceAbility::GetInstance()->ManualStart();
43    auto cupsPrinter = std::make_shared<CupsPrinterInfo>();
44    PrintServiceAbility::GetInstance()->printSystemData_.addedPrinterMap_.Insert(DEFAULT_PRINTERID, cupsPrinter);
45    PrintServiceAbility::GetInstance()->StartService();
46    std::string fileUri = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
47    std::vector<std::string> fileList;
48    fileList.push_back(fileUri);
49    uint32_t fd = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
50    std::vector<uint32_t> fdList;
51    fdList.push_back(fd);
52    std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
53    PrintServiceAbility::GetInstance()->StartPrint(fileList, fdList, taskId);
54    PrintServiceAbility::GetInstance()->OnStop();
55}
56
57void TestStopPrint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
58{
59    std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
60    PrintServiceAbility::GetInstance()->StopPrint(taskId);
61}
62
63void TestConnectPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
64{
65    std::string printerId = size ? dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH) : DEFAULT_PRINTERID;
66    PrinterInfo printerInfo;
67    printerInfo.SetPrinterId(printerId);
68    printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
69    printerInfo.SetOption(JOB_OPTIONS);
70    std::vector <PrinterInfo> printerInfos;
71    printerInfos.push_back(printerInfo);
72    PrintServiceAbility::GetInstance()->AddPrinters(printerInfos);
73    PrintServiceAbility::GetInstance()->ConnectPrinter(printerId);
74    PrintServiceAbility::GetInstance()->DisconnectPrinter(printerId);
75}
76
77void TestDisconnectPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
78{
79    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
80    PrintServiceAbility::GetInstance()->DisconnectPrinter(printerId);
81}
82
83void TestStartDiscoverPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
84{
85    std::vector <PrintExtensionInfo> printExtensionInfos;
86    PrintServiceAbility::GetInstance()->QueryAllExtension(printExtensionInfos);
87    std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
88    std::vector <std::string> extensionIds;
89    extensionIds.push_back(extensionId);
90    for (auto &printExtensionInfo: printExtensionInfos) {
91        extensionIds.push_back(printExtensionInfo.GetExtensionId());
92    }
93    PrintServiceAbility::GetInstance()->StartDiscoverPrinter(extensionIds);
94    PrintServiceAbility::GetInstance()->StopDiscoverPrinter();
95}
96
97void TestQueryAllExtension(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
98{
99    PrintExtensionInfo printExtensionInfo;
100    printExtensionInfo.SetExtensionId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
101    std::vector<PrintExtensionInfo> printExtensionInfos;
102    printExtensionInfos.push_back(printExtensionInfo);
103    PrintServiceAbility::GetInstance()->QueryAllExtension(printExtensionInfos);
104}
105
106void TestStartPrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
107{
108    PrinterInfo printerInfo;
109    printerInfo.SetPrinterId(DEFAULT_PRINTERID);
110    printerInfo.SetPrinterName(DEFAULT_PRINTERID);
111    std::vector <PrinterInfo> printerInfos;
112    PrinterCapability printerCaps;
113    printerCaps.SetColorMode(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
114    printerInfos.push_back(printerInfo);
115
116    PrintServiceAbility::GetInstance()->AddPrinters(printerInfos);
117    PrintServiceAbility::GetInstance()->UpdatePrinters(printerInfos);
118
119    PrintJob testJob;
120    testJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
121    std::vector <uint32_t> files = {1};
122    testJob.SetFdList(files);
123    OHOS::Print::PrintPageSize pageSize;
124    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
125    testJob.SetPageSize(pageSize);
126    testJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
127    testJob.SetOption(JOB_OPTIONS);
128    PrintServiceAbility::GetInstance()->StartPrintJob(testJob);
129}
130
131void TestCancelPrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
132{
133    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
134    PrintServiceAbility::GetInstance()->CancelPrintJob(jobId);
135}
136
137void TestAddPrinters(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
138{
139    PrinterInfo printerInfo;
140    printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
141    printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
142    printerInfo.SetOption(JOB_OPTIONS);
143    std::vector<PrinterInfo> printerInfos;
144    printerInfos.push_back(printerInfo);
145    PrintServiceAbility::GetInstance()->AddPrinters(printerInfos);
146}
147
148void TestRemovePrinters(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
149{
150    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
151    std::vector<std::string> printerIds;
152    printerIds.push_back(printerId);
153    PrintServiceAbility::GetInstance()->RemovePrinters(printerIds);
154}
155
156void TestUpdatePrinters(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
157{
158    PrinterInfo printerInfo;
159    printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
160    printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
161    printerInfo.SetOption(JOB_OPTIONS);
162    std::vector<PrinterInfo> printerInfos;
163    printerInfos.push_back(printerInfo);
164    PrintServiceAbility::GetInstance()->UpdatePrinters(printerInfos);
165    return;
166}
167
168void TestUpdatePrinterState(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
169{
170    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
171    uint32_t state = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
172    PrintServiceAbility::GetInstance()->UpdatePrinterState(printerId, state);
173}
174
175void TestUpdatePrintJobStateOnlyForSystemApp(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
176{
177    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
178    uint32_t state = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
179    uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
180    PrintServiceAbility::GetInstance()->UpdatePrintJobStateOnlyForSystemApp(jobId, state, subState);
181}
182
183void TestUpdateExtensionInfo(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
184{
185    std::string extInfo = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
186    PrintServiceAbility::GetInstance()->UpdateExtensionInfo(extInfo);
187}
188
189void TestRequestPreview(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
190{
191    PrintJob printJob;
192    printJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
193    std::vector<uint32_t> files = {1};
194    printJob.SetFdList(files);
195    OHOS::Print::PrintPageSize pageSize;
196    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
197    printJob.SetPageSize(pageSize);
198    printJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
199    printJob.SetOption(JOB_OPTIONS);
200    std::string previewResult = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
201    PrintServiceAbility::GetInstance()->RequestPreview(printJob, previewResult);
202}
203
204void TestQueryPrinterCapability(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
205{
206    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
207    PrintServiceAbility::GetInstance()->QueryPrinterCapability(printerId);
208}
209
210void TestOn(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
211{
212    PrintDocumentAdapter *printerAdapterPtr = new PrintDocumentAdapter();
213    sptr <PrintCallback> callback = new(std::nothrow) PrintCallback(printerAdapterPtr);
214    if (callback != nullptr) {
215        std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
216        std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
217        PrintServiceAbility::GetInstance()->On(taskId, type, callback);
218    } else {
219        delete printerAdapterPtr;
220        printerAdapterPtr = nullptr;
221    }
222}
223
224void TestOff(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
225{
226    std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
227    std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
228    PrintServiceAbility::GetInstance()->Off(taskId, type);
229}
230
231void TestCallback(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
232{
233    PrintDocumentAdapter *printerAdapterPtr = new PrintDocumentAdapter();
234    sptr <PrintCallback> callback = new(std::nothrow) PrintCallback(printerAdapterPtr);
235    if (callback != nullptr) {
236        std::string type = PRINTER_DISCOVER_EVENT_TYPE;
237        PrintServiceAbility::GetInstance()->RegisterPrinterCallback(type, callback);
238        PrintServiceAbility::GetInstance()->UnregisterPrinterCallback(type);
239    } else {
240        delete printerAdapterPtr;
241        printerAdapterPtr = nullptr;
242    }
243    std::vector <PrintExtensionInfo> printExtensionInfos;
244    PrintServiceAbility::GetInstance()->QueryAllExtension(printExtensionInfos);
245    std::vector <std::string> extensionIds;
246    for (auto &printExtensionInfo: printExtensionInfos) {
247        extensionIds.push_back(printExtensionInfo.GetExtensionId());
248    }
249    PrintServiceAbility::GetInstance()->StartDiscoverPrinter(extensionIds);
250
251    for (auto &printExtensionInfo: printExtensionInfos) {
252        PrintServiceAbility::GetInstance()->RegisterExtCallback(printExtensionInfo.GetExtensionId(), nullptr);
253        PrintServiceAbility::GetInstance()->UnregisterAllExtCallback(printExtensionInfo.GetExtensionId());
254    }
255
256    std::string extensionCID = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
257    PrintServiceAbility::GetInstance()->RegisterExtCallback(extensionCID, nullptr);
258    PrintServiceAbility::GetInstance()->UnregisterAllExtCallback(extensionCID);
259}
260
261void TestLoadExtSuccess(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
262{
263    std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
264    PrintServiceAbility::GetInstance()->LoadExtSuccess(extensionId);
265}
266
267void TestQueryAllPrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
268{
269    PrintJob printJob;
270    printJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
271    std::vector<uint32_t> files = {0};
272    printJob.SetFdList(files);
273    OHOS::Print::PrintPageSize pageSize;
274    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
275    printJob.SetPageSize(pageSize);
276    printJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
277    std::vector<PrintJob> printJobs;
278    printJobs.push_back(printJob);
279    PrintServiceAbility::GetInstance()->QueryAllPrintJob(printJobs);
280}
281
282void TestQueryPrintJobById(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
283{
284    PrintJob printJob;
285    printJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
286    std::vector<uint32_t> files = {0};
287    printJob.SetFdList(files);
288    OHOS::Print::PrintPageSize pageSize;
289    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
290    printJob.SetPageSize(pageSize);
291    printJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
292    std::string printJobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
293    PrintServiceAbility::GetInstance()->QueryPrintJobById(printJobId, printJob);
294}
295
296void TestAddPrinterToCups(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
297{
298    std::string printerUri = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
299    std::string printerName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
300    std::string printerMake = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
301    PrintServiceAbility::GetInstance()->AddPrinterToCups(printerUri, printerName, printerMake);
302}
303
304void TestQueryPrinterCapabilityByUri(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
305{
306    std::string printerUri = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
307    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
308    PrinterCapability printerCaps;
309    PrintServiceAbility::GetInstance()->SetHelper(nullptr);
310    PrintServiceAbility::GetInstance()->QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
311}
312
313void TestPrintByAdapter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
314{
315    std::string jobName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
316    PrintAttributes printAttributes;
317    std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
318    PrintServiceAbility::GetInstance()->PrintByAdapter(jobName, printAttributes, taskId);
319}
320
321void TestStartGetPrintFile(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
322{
323    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
324    PrintAttributes printAttributes;
325    uint32_t fd = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
326    PrintServiceAbility::GetInstance()->StartGetPrintFile(jobId, printAttributes, fd);
327}
328
329void TestQueryPrinterInfoByPrinterId(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
330{
331    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
332    PrinterInfo printerInfo;
333    printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
334    printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
335    printerInfo.SetOption(JOB_OPTIONS);
336    PrintServiceAbility::GetInstance()->QueryPrinterInfoByPrinterId(printerId, printerInfo);
337}
338
339void TestNotifyPrintService(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
340{
341    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
342    std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
343    PrintServiceAbility::GetInstance()->NotifyPrintService(jobId, type);
344}
345
346void TestQueryAddedPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
347{
348    std::string printerName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
349    std::vector<std::string> printerNameList;
350    printerNameList.push_back(printerName);
351    PrintServiceAbility::GetInstance()->QueryAddedPrinter(printerNameList);
352}
353
354void TestQueryPrinterProperties(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
355{
356    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
357    std::string key = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
358    std::vector<std::string> keyList;
359    keyList.push_back(key);
360    std::string value = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
361    std::vector<std::string> valueList;
362    valueList.push_back(value);
363    PrintServiceAbility::GetInstance()->QueryPrinterProperties(printerId, keyList, valueList);
364}
365
366void TestUpdatePrintJobState(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
367{
368    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
369    uint32_t state = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
370    uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
371    PrintServiceAbility::GetInstance()->UpdatePrintJobState(jobId, state, subState);
372}
373
374void TestGetPrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
375{
376    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
377    std::string printerPreference = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
378    PrintServiceAbility::GetInstance()->GetPrinterPreference(printerId, printerPreference);
379}
380
381void TestSetPrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
382{
383    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
384    std::string printerPreference = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
385    PrintServiceAbility::GetInstance()->SetPrinterPreference(printerId, printerPreference);
386}
387
388void TestSetDefaultPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
389{
390    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
391    uint32_t type = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
392    PrintServiceAbility::GetInstance()->SetDefaultPrinter(printerId, type);
393}
394
395void TestDeletePrinterFromCups(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
396{
397    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
398    std::string printerName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
399    std::string printerMake = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
400    PrintServiceAbility::GetInstance()->DeletePrinterFromCups(printerId, printerName, printerMake);
401}
402
403void TestDiscoverUsbPrinters(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
404{
405    PrinterInfo printerInfo;
406    printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
407    printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
408    printerInfo.SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
409    printerInfo.SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
410    std::vector<PrinterInfo> printers;
411    printers.push_back(printerInfo);
412    PrintServiceAbility::GetInstance()->DiscoverUsbPrinters(printers);
413}
414
415void TestStartNativePrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
416{
417    PrintJob testJob;
418    testJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
419    std::vector<uint32_t> files = {1};
420    testJob.SetFdList(files);
421    OHOS::Print::PrintPageSize pageSize;
422    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
423    testJob.SetPageSize(pageSize);
424    testJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
425    testJob.SetOption(JOB_OPTIONS);
426    PrintServiceAbility::GetInstance()->StartNativePrintJob(testJob);
427}
428
429void TestNotifyPrintServiceEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
430{
431    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
432    uint32_t event = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
433    PrintServiceAbility::GetInstance()->NotifyPrintServiceEvent(jobId, event);
434}
435
436// below are private test
437void TestUpdateQueuedJobList(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
438{
439    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
440    std::string printJobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
441    auto printJob = std::make_shared<PrintJob>();
442    printJob->SetJobId(printJobId);
443    printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
444    PrintServiceAbility::GetInstance()->UpdateQueuedJobList(printJobId, printJob);
445}
446
447void TestUpdatePrintJobOptionByPrinterId(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
448{
449    PrintJob printJob;
450    printJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
451    std::vector<uint32_t> files = {0};
452    printJob.SetFdList(files);
453    OHOS::Print::PrintPageSize pageSize;
454    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
455    printJob.SetPageSize(pageSize);
456    printJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
457    PrintServiceAbility::GetInstance()->UpdatePrintJobOptionByPrinterId(printJob);
458}
459
460void TestDelayStartDiscovery(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
461{
462    std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
463    PrintServiceAbility::GetInstance()->DelayStartDiscovery(extensionId);
464}
465
466void TestAdapterGetFileCallBack(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
467{
468    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
469    uint32_t state = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
470    uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
471    PrintServiceAbility::GetInstance()->AdapterGetFileCallBack(jobId, state, subState);
472}
473
474void TestAddNativePrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
475{
476    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
477    PrintJob printJob;
478    PrintServiceAbility::GetInstance()->AddNativePrintJob(jobId, printJob);
479}
480
481void TestIsQueuedJobListEmpty(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
482{
483    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
484    PrintServiceAbility::GetInstance()->IsQueuedJobListEmpty(jobId);
485}
486
487void TestSetPrintJobCanceled(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
488{
489    PrintJob printJob;
490    std::string printerid = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
491    printJob.SetPrinterId(printerid);
492    PrintServiceAbility::GetInstance()->SetPrintJobCanceled(printJob);
493}
494
495void TestCancelUserPrintJobs(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
496{
497    int32_t userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
498    PrintServiceAbility::GetInstance()->CancelUserPrintJobs(userId);
499    PrintServiceAbility::GetInstance()->CallStatusBar();
500}
501
502void TestSendExtensionEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
503{
504    std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
505    std::string extInfo = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
506    PrintServiceAbility::GetInstance()->SendExtensionEvent(extensionId, extInfo);
507    PrintServiceAbility::GetInstance()->UpdatePrintUserMap();
508}
509
510void TestNotifyAdapterJobChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
511{
512    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
513    uint32_t state = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
514    uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
515    PrintServiceAbility::GetInstance()->notifyAdapterJobChanged(jobId, state, subState);
516}
517
518void TestRegisterAdapterListener(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
519{
520    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
521    PrintServiceAbility::GetInstance()->RegisterAdapterListener(jobId);
522}
523
524void TestisEprint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
525{
526    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
527    PrintServiceAbility::GetInstance()->isEprint(printerId);
528    PrintServiceAbility::GetInstance()->GetPrintJobOrderId();
529    PrintServiceAbility::GetInstance()->WritePreferenceToFile();
530}
531
532void TestBuildPrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
533{
534    std::string option = "{\
535        \"cupsOptions\" : {\
536            \"supportedPageSizeArray\" : \"String\",\
537            \"orientation-requested-supported\" : \"String\",\
538            \"print-quality-supported\" : \"String\"\
539        }\
540    }";
541    PrinterCapability cap;
542    cap.SetOption(option);
543    PrinterPreference printPreference;
544    PrintServiceAbility::GetInstance()->BuildPrinterPreference(cap, printPreference);
545    std::string optionRandom = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
546    cap.SetOption(optionRandom);
547    PrintServiceAbility::GetInstance()->BuildPrinterPreference(cap, printPreference);
548}
549
550void TestBuildPrinterPreferenceByDefault(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
551{
552    std::string optJson = "{\
553        \"defaultPageSizeId\" : \"String\",\
554        \"orientation-requested-default\" : \"String\",\
555        \"sides-default\" : \"String\",\
556        \"print-quality-default\" : \"String\"\
557    }";
558    nlohmann::json capOpt = nlohmann::json::parse(optJson);
559    PreferenceSetting printerDefaultAttr;
560    PrintServiceAbility::GetInstance()->BuildPrinterPreferenceByDefault(capOpt, printerDefaultAttr);
561    printerDefaultAttr.pagesizeId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
562    PrintServiceAbility::GetInstance()->BuildPrinterPreferenceByDefault(capOpt, printerDefaultAttr);
563}
564
565void TestBuildPrinterPreferenceByOption(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
566{
567    std::string key = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
568    std::string supportedOpts = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
569    std::string optAttr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
570    std::vector<std::string> optAttrs;
571    optAttrs.push_back(optAttr);
572    PrintServiceAbility::GetInstance()->BuildPrinterPreferenceByOption(key, supportedOpts, optAttrs);
573}
574
575void TestBuildPrinterAttrComponentByJson(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
576{
577    std::string key = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
578    std::string arrObject = "{\
579        \"cupsOptions\" : [\
580            \"supportedPageSizeArray\", \
581            \"orientation-requested-supported\", \
582            \"print-quality-supported\"\
583        ]\
584    }";
585    nlohmann::json jsonArrObject = nlohmann::json::parse(arrObject);
586    std::string printerAttr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
587    std::vector<std::string> printerAttrs;
588    printerAttrs.push_back(printerAttr);
589    PrintServiceAbility::GetInstance()->BuildPrinterAttrComponentByJson(key, jsonArrObject, printerAttrs);
590}
591
592void TestCheckIsDefaultPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
593{
594    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
595    PrintServiceAbility::GetInstance()->CheckIsDefaultPrinter(printerId);
596}
597
598void TestCheckIsLastUsedPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
599{
600    std::string printerName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
601    PrintServiceAbility::GetInstance()->CheckIsLastUsedPrinter(printerName);
602}
603
604void TestSetLastUsedPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
605{
606    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
607    PrintServiceAbility::GetInstance()->SetLastUsedPrinter(printerId);
608}
609
610void TestSendPrintJobEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
611{
612    PrintJob jobInfo;
613    uint32_t jobStateArr[] = {PRINT_JOB_COMPLETED, PRINT_JOB_BLOCKED, PRINT_JOB_COMPLETED};
614    for (auto jobState : jobStateArr) {
615        jobInfo.SetJobState(jobState);
616        PrintServiceAbility::GetInstance()->SendPrintJobEvent(jobInfo);
617    }
618    uint32_t jobState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
619    jobInfo.SetJobState(jobState);
620    PrintServiceAbility::GetInstance()->SendPrintJobEvent(jobInfo);
621}
622
623void TestStartPrintJobCB(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
624{
625    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
626    auto printJob = std::make_shared<PrintJob>();
627    printJob->SetJobId(jobId);
628    printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
629    PrintServiceAbility::GetInstance()->StartPrintJobCB(jobId, printJob);
630}
631
632void TestCheckPrinterUriDifferent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
633{
634    auto printerInfo = std::make_shared<PrinterInfo>();
635    printerInfo->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
636    printerInfo->SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
637    printerInfo->SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
638    printerInfo->SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
639    PrintServiceAbility::GetInstance()->CheckPrinterUriDifferent(printerInfo);
640}
641
642void TestUpdatePrinterCapability(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
643{
644    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
645    PrinterInfo printerInfo;
646    printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
647    printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
648    printerInfo.SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
649    printerInfo.SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
650    PrintServiceAbility::GetInstance()->UpdatePrinterCapability(printerId, printerInfo);
651}
652
653void TestReportCompletedPrint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
654{
655    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
656    PrintServiceAbility::GetInstance()->ReportCompletedPrint(printerId);
657}
658
659void TestReportHisysEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
660{
661    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
662    auto printJob = std::make_shared<PrintJob>();
663    printJob->SetJobId(jobId);
664    printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
665    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
666    uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
667    PrintServiceAbility::GetInstance()->ReportHisysEvent(printJob, printerId, subState);
668}
669
670void TestNotifyAppJobQueueChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
671{
672    std::string applyResult = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
673    PrintServiceAbility::GetInstance()->NotifyAppJobQueueChanged(applyResult);
674}
675
676void TestSendPrinterChangeEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
677{
678    int event = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
679    PrinterInfo printerInfo;
680    printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
681    printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
682    printerInfo.SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
683    printerInfo.SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
684    PrintServiceAbility::GetInstance()->SendPrinterChangeEvent(event, printerInfo);
685    PrintServiceAbility::GetInstance()->DestroyExtension();
686    PrintServiceAbility::GetInstance()->ReduceAppCount();
687}
688
689void TestCheckJobQueueBlocked(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
690{
691    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
692    PrintJob printJob;
693    printJob.SetJobId(jobId);
694    printJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
695    PrintServiceAbility::GetInstance()->CheckJobQueueBlocked(printJob);
696}
697
698void TestGetListeningState(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
699{
700    uint32_t subState = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
701    PrintServiceAbility::GetInstance()->GetListeningState(subState);
702}
703
704void TestChangeDefaultPrinterForDelete(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
705{
706    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
707    auto userData = std::make_shared<PrintUserData>();
708    PrintServiceAbility::GetInstance()->ChangeDefaultPrinterForDelete(userData, printerId);
709}
710
711void TestGetUserDataByUserId(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
712{
713    int32_t userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
714    PrintServiceAbility::GetInstance()->GetUserDataByUserId(userId);
715}
716
717void TestDetermineUserJobStatus(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
718{
719    std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
720    auto printJob = std::make_shared<PrintJob>();
721    printJob->SetJobId(jobId);
722    printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
723    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
724    std::map<std::string, std::shared_ptr<PrintJob>> jobList;
725    jobList[jobId] = printJob;
726    PrintServiceAbility::GetInstance()->DetermineUserJobStatus(jobList);
727}
728
729void TestNotifyCurrentUserChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
730{
731    int32_t userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
732    PrintServiceAbility::GetInstance()->NotifyCurrentUserChanged(userId);
733}
734
735void TestWriteEprinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
736{
737    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
738    PrinterCapability printerCaps;
739    PrintPageSize pageSize;
740    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
741    std::vector<PrintPageSize> pageSizeList;
742    pageSizeList.push_back(pageSize);
743    printerCaps.SetSupportedPageSize(pageSizeList);
744    PrintServiceAbility::GetInstance()->WriteEprinterPreference(printerId, printerCaps);
745}
746
747void TestWritePrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
748{
749    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
750    PrinterCapability printerCaps;
751    PrintPageSize pageSize;
752    pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
753    std::vector<PrintPageSize> pageSizeList;
754    pageSizeList.push_back(pageSize);
755    printerCaps.SetSupportedPageSize(pageSizeList);
756    printerCaps.SetOption(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
757    PrintServiceAbility::GetInstance()->WritePrinterPreference(printerId, printerCaps);
758}
759
760void TestReadPreferenceFromFile(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
761{
762    std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
763    std::string printPreference = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
764    PrintServiceAbility::GetInstance()->ReadPreferenceFromFile(printerId, printPreference);
765}
766
767void TestMoreFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
768{
769    TestChangeDefaultPrinterForDelete(data, size, dataProvider);
770    TestGetUserDataByUserId(data, size, dataProvider);
771    TestDetermineUserJobStatus(data, size, dataProvider);
772    TestNotifyCurrentUserChanged(data, size, dataProvider);
773    TestWriteEprinterPreference(data, size, dataProvider);
774    TestWritePrinterPreference(data, size, dataProvider);
775    TestReadPreferenceFromFile(data, size, dataProvider);
776}
777
778void TestNotPublicFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
779{
780    TestDiscoverUsbPrinters(data, size, dataProvider);
781    TestStartNativePrintJob(data, size, dataProvider);
782    TestNotifyPrintServiceEvent(data, size, dataProvider);
783    TestUpdateQueuedJobList(data, size, dataProvider);
784    TestUpdatePrintJobOptionByPrinterId(data, size, dataProvider);
785    TestDelayStartDiscovery(data, size, dataProvider);
786    TestAdapterGetFileCallBack(data, size, dataProvider);
787    TestAddNativePrintJob(data, size, dataProvider);
788    TestIsQueuedJobListEmpty(data, size, dataProvider);
789    TestSetPrintJobCanceled(data, size, dataProvider);
790    TestCancelUserPrintJobs(data, size, dataProvider);
791    TestSendExtensionEvent(data, size, dataProvider);
792    TestNotifyAdapterJobChanged(data, size, dataProvider);
793    TestRegisterAdapterListener(data, size, dataProvider);
794    TestisEprint(data, size, dataProvider);
795    TestBuildPrinterPreferenceByOption(data, size, dataProvider);
796    TestBuildPrinterPreference(data, size, dataProvider);
797    TestBuildPrinterPreferenceByDefault(data, size, dataProvider);
798    TestBuildPrinterPreferenceByOption(data, size, dataProvider);
799    TestBuildPrinterAttrComponentByJson(data, size, dataProvider);
800    TestCheckIsDefaultPrinter(data, size, dataProvider);
801    TestCheckIsLastUsedPrinter(data, size, dataProvider);
802    TestSetLastUsedPrinter(data, size, dataProvider);
803    TestSendPrintJobEvent(data, size, dataProvider);
804    TestStartPrintJobCB(data, size, dataProvider);
805    TestCheckPrinterUriDifferent(data, size, dataProvider);
806    TestUpdatePrinterCapability(data, size, dataProvider);
807    TestReportCompletedPrint(data, size, dataProvider);
808    TestReportHisysEvent(data, size, dataProvider);
809    TestNotifyAppJobQueueChanged(data, size, dataProvider);
810    TestSendPrinterChangeEvent(data, size, dataProvider);
811    TestCheckJobQueueBlocked(data, size, dataProvider);
812    TestGetListeningState(data, size, dataProvider);
813    TestMoreFunction(data, size, dataProvider);
814}
815
816}  // namespace Print
817}  // namespace OHOS
818
819/* Fuzzer entry point */
820extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
821{
822    /* Run your code on data */
823    if (data == nullptr) {
824        return 0;
825    }
826
827    if (size < OHOS::Print::U32_AT_SIZE) {
828    }
829
830    FuzzedDataProvider dataProvider(data, size);
831    OHOS::Print::TestStartPrint(data, size, &dataProvider);
832    OHOS::Print::TestStopPrint(data, size, &dataProvider);
833    OHOS::Print::TestConnectPrinter(data, size, &dataProvider);
834    OHOS::Print::TestDisconnectPrinter(data, size, &dataProvider);
835    OHOS::Print::TestStartDiscoverPrinter(data, size, &dataProvider);
836    OHOS::Print::TestQueryAllExtension(data, size, &dataProvider);
837    OHOS::Print::TestStartPrintJob(data, size, &dataProvider);
838    OHOS::Print::TestCancelPrintJob(data, size, &dataProvider);
839    OHOS::Print::TestAddPrinters(data, size, &dataProvider);
840    OHOS::Print::TestRemovePrinters(data, size, &dataProvider);
841    OHOS::Print::TestUpdatePrinters(data, size, &dataProvider);
842    OHOS::Print::TestUpdatePrinterState(data, size, &dataProvider);
843    OHOS::Print::TestUpdatePrintJobStateOnlyForSystemApp(data, size, &dataProvider);
844    OHOS::Print::TestUpdateExtensionInfo(data, size, &dataProvider);
845    OHOS::Print::TestRequestPreview(data, size, &dataProvider);
846    OHOS::Print::TestQueryPrinterCapability(data, size, &dataProvider);
847    OHOS::Print::TestOn(data, size, &dataProvider);
848    OHOS::Print::TestOff(data, size, &dataProvider);
849    OHOS::Print::TestCallback(data, size, &dataProvider);
850    OHOS::Print::TestLoadExtSuccess(data, size, &dataProvider);
851    OHOS::Print::TestQueryAllPrintJob(data, size, &dataProvider);
852    OHOS::Print::TestQueryPrintJobById(data, size, &dataProvider);
853    OHOS::Print::TestAddPrinterToCups(data, size, &dataProvider);
854    OHOS::Print::TestQueryPrinterCapabilityByUri(data, size, &dataProvider);
855    OHOS::Print::TestPrintByAdapter(data, size, &dataProvider);
856    OHOS::Print::TestStartGetPrintFile(data, size, &dataProvider);
857    OHOS::Print::TestNotifyPrintService(data, size, &dataProvider);
858    OHOS::Print::TestQueryPrinterInfoByPrinterId(data, size, &dataProvider);
859    OHOS::Print::TestQueryAddedPrinter(data, size, &dataProvider);
860    OHOS::Print::TestQueryPrinterProperties(data, size, &dataProvider);
861    OHOS::Print::TestUpdatePrintJobState(data, size, &dataProvider);
862    OHOS::Print::TestGetPrinterPreference(data, size, &dataProvider);
863    OHOS::Print::TestSetPrinterPreference(data, size, &dataProvider);
864    OHOS::Print::TestSetDefaultPrinter(data, size, &dataProvider);
865    OHOS::Print::TestDeletePrinterFromCups(data, size, &dataProvider);
866    OHOS::Print::TestNotPublicFunction(data, size, &dataProvider);
867    return 0;
868}
869