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 
27 namespace OHOS {
28 namespace Print {
29 constexpr uint8_t MAX_STRING_LENGTH = 20;
30 constexpr int MAX_SET_NUMBER = 128;
31 constexpr size_t U32_AT_SIZE = 4;
32 static 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\"]}";
36 static const std::string DEFAULT_PRINTERID = "testId";
37 
TestStartPrint(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)38 void 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 
TestStopPrint(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)57 void 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 
TestConnectPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)63 void 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 
TestDisconnectPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)77 void 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 
TestStartDiscoverPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)83 void 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 
TestQueryAllExtension(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)97 void 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 
TestStartPrintJob(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)106 void 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 
TestCancelPrintJob(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)131 void 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 
TestAddPrinters(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)137 void 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 
TestRemovePrinters(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)148 void 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 
TestUpdatePrinters(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)156 void 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 
TestUpdatePrinterState(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)168 void 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 
TestUpdatePrintJobStateOnlyForSystemApp(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)175 void 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 
TestUpdateExtensionInfo(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)183 void 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 
TestRequestPreview(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)189 void 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 
TestQueryPrinterCapability(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)204 void 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 
TestOn(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)210 void 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 
TestOff(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)224 void 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 
TestCallback(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)231 void 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 
TestLoadExtSuccess(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)261 void 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 
TestQueryAllPrintJob(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)267 void 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 
TestQueryPrintJobById(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)282 void 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 
TestAddPrinterToCups(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)296 void 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 
TestQueryPrinterCapabilityByUri(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)304 void 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 
TestPrintByAdapter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)313 void 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 
TestStartGetPrintFile(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)321 void 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 
TestQueryPrinterInfoByPrinterId(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)329 void 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 
TestNotifyPrintService(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)339 void 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 
TestQueryAddedPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)346 void 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 
TestQueryPrinterProperties(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)354 void 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 
TestUpdatePrintJobState(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)366 void 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 
TestGetPrinterPreference(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)374 void 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 
TestSetPrinterPreference(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)381 void 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 
TestSetDefaultPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)388 void 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 
TestDeletePrinterFromCups(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)395 void TestDeletePrinterFromCups(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
396 {
397     std::string printerName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
398     PrintServiceAbility::GetInstance()->DeletePrinterFromCups(printerName);
399 }
400 
TestDiscoverUsbPrinters(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)401 void TestDiscoverUsbPrinters(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
402 {
403     PrinterInfo printerInfo;
404     printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
405     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
406     printerInfo.SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
407     printerInfo.SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
408     std::vector<PrinterInfo> printers;
409     printers.push_back(printerInfo);
410     PrintServiceAbility::GetInstance()->DiscoverUsbPrinters(printers);
411 }
412 
TestStartNativePrintJob(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)413 void TestStartNativePrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
414 {
415     PrintJob testJob;
416     testJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
417     std::vector<uint32_t> files = {1};
418     testJob.SetFdList(files);
419     OHOS::Print::PrintPageSize pageSize;
420     pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
421     testJob.SetPageSize(pageSize);
422     testJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
423     testJob.SetOption(JOB_OPTIONS);
424     PrintServiceAbility::GetInstance()->StartNativePrintJob(testJob);
425 }
426 
TestNotifyPrintServiceEvent(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)427 void TestNotifyPrintServiceEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
428 {
429     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
430     uint32_t event = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
431     PrintServiceAbility::GetInstance()->NotifyPrintServiceEvent(jobId, event);
432 }
433 
434 // below are private test
TestUpdateQueuedJobList(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)435 void TestUpdateQueuedJobList(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
436 {
437     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
438     std::string printJobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
439     auto printJob = std::make_shared<PrintJob>();
440     printJob->SetJobId(printJobId);
441     printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
442     PrintServiceAbility::GetInstance()->UpdateQueuedJobList(printJobId, printJob);
443 }
444 
TestUpdatePrintJobOptionByPrinterId(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)445 void TestUpdatePrintJobOptionByPrinterId(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
446 {
447     PrintJob printJob;
448     printJob.SetJobId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
449     std::vector<uint32_t> files = {0};
450     printJob.SetFdList(files);
451     OHOS::Print::PrintPageSize pageSize;
452     pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
453     printJob.SetPageSize(pageSize);
454     printJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
455     PrintServiceAbility::GetInstance()->UpdatePrintJobOptionByPrinterId(printJob);
456 }
457 
TestDelayStartDiscovery(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)458 void TestDelayStartDiscovery(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
459 {
460     std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
461     PrintServiceAbility::GetInstance()->DelayStartDiscovery(extensionId);
462 }
463 
TestAdapterGetFileCallBack(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)464 void TestAdapterGetFileCallBack(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
465 {
466     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
467     uint32_t state = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
468     uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
469     PrintServiceAbility::GetInstance()->AdapterGetFileCallBack(jobId, state, subState);
470 }
471 
TestAddNativePrintJob(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)472 void TestAddNativePrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
473 {
474     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
475     PrintJob printJob;
476     PrintServiceAbility::GetInstance()->AddNativePrintJob(jobId, printJob);
477 }
478 
TestIsQueuedJobListEmpty(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)479 void TestIsQueuedJobListEmpty(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
480 {
481     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
482     PrintServiceAbility::GetInstance()->IsQueuedJobListEmpty(jobId);
483 }
484 
TestSetPrintJobCanceled(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)485 void TestSetPrintJobCanceled(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
486 {
487     PrintJob printJob;
488     std::string printerid = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
489     printJob.SetPrinterId(printerid);
490     PrintServiceAbility::GetInstance()->SetPrintJobCanceled(printJob);
491 }
492 
TestCancelUserPrintJobs(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)493 void TestCancelUserPrintJobs(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
494 {
495     int32_t userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
496     PrintServiceAbility::GetInstance()->CancelUserPrintJobs(userId);
497     PrintServiceAbility::GetInstance()->CallStatusBar();
498 }
499 
TestSendExtensionEvent(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)500 void TestSendExtensionEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
501 {
502     std::string extensionId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
503     std::string extInfo = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
504     PrintServiceAbility::GetInstance()->SendExtensionEvent(extensionId, extInfo);
505     PrintServiceAbility::GetInstance()->UpdatePrintUserMap();
506 }
507 
TestNotifyAdapterJobChanged(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)508 void TestNotifyAdapterJobChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
509 {
510     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
511     uint32_t state = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
512     uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
513     PrintServiceAbility::GetInstance()->notifyAdapterJobChanged(jobId, state, subState);
514 }
515 
TestRegisterAdapterListener(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)516 void TestRegisterAdapterListener(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
517 {
518     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
519     PrintServiceAbility::GetInstance()->RegisterAdapterListener(jobId);
520 }
521 
TestisEprint(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)522 void TestisEprint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
523 {
524     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
525     PrintServiceAbility::GetInstance()->isEprint(printerId);
526     PrintServiceAbility::GetInstance()->GetPrintJobOrderId();
527     PrintServiceAbility::GetInstance()->WritePreferenceToFile();
528 }
529 
TestBuildPrinterPreference(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)530 void TestBuildPrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
531 {
532     std::string option = "{\
533         \"cupsOptions\" : {\
534             \"orientation-requested-supported\" : \"String\",\
535             \"print-quality-supported\" : \"String\"\
536         }\
537     }";
538     PrinterCapability cap;
539     cap.SetOption(option);
540     PrinterPreference printPreference;
541     PrintServiceAbility::GetInstance()->BuildPrinterPreference(cap, printPreference);
542     std::string optionRandom = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
543     cap.SetOption(optionRandom);
544     PrintServiceAbility::GetInstance()->BuildPrinterPreference(cap, printPreference);
545 }
546 
TestBuildPrinterPreferenceByDefault(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)547 void TestBuildPrinterPreferenceByDefault(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
548 {
549     std::string optJson = "{\
550         \"defaultPageSizeId\" : \"String\",\
551         \"orientation-requested-default\" : \"String\",\
552         \"sides-default\" : \"String\",\
553         \"print-quality-default\" : \"String\"\
554     }";
555     nlohmann::json capOpt = nlohmann::json::parse(optJson);
556     PreferenceSetting printerDefaultAttr;
557     PrintServiceAbility::GetInstance()->BuildPrinterPreferenceByDefault(capOpt, printerDefaultAttr);
558     printerDefaultAttr.pagesizeId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
559     PrintServiceAbility::GetInstance()->BuildPrinterPreferenceByDefault(capOpt, printerDefaultAttr);
560 }
561 
TestBuildPrinterPreferenceByOption(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)562 void TestBuildPrinterPreferenceByOption(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
563 {
564     std::string key = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
565     std::string supportedOpts = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
566     std::string optAttr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
567     std::vector<std::string> optAttrs;
568     optAttrs.push_back(optAttr);
569     PrintServiceAbility::GetInstance()->BuildPrinterPreferenceByOption(key, supportedOpts, optAttrs);
570 }
571 
TestBuildPrinterAttrComponentByJson(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)572 void TestBuildPrinterAttrComponentByJson(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
573 {
574     std::string key = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
575     std::string arrObject = "{\
576         \"cupsOptions\" : [\
577             \"orientation-requested-supported\", \
578             \"print-quality-supported\"\
579         ]\
580     }";
581     nlohmann::json jsonArrObject = nlohmann::json::parse(arrObject);
582     std::string printerAttr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
583     std::vector<std::string> printerAttrs;
584     printerAttrs.push_back(printerAttr);
585     PrintServiceAbility::GetInstance()->BuildPrinterAttrComponentByJson(key, jsonArrObject, printerAttrs);
586 }
587 
TestCheckIsDefaultPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)588 void TestCheckIsDefaultPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
589 {
590     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
591     PrintServiceAbility::GetInstance()->CheckIsDefaultPrinter(printerId);
592 }
593 
TestCheckIsLastUsedPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)594 void TestCheckIsLastUsedPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
595 {
596     std::string printerName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
597     PrintServiceAbility::GetInstance()->CheckIsLastUsedPrinter(printerName);
598 }
599 
TestSetLastUsedPrinter(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)600 void TestSetLastUsedPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
601 {
602     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
603     PrintServiceAbility::GetInstance()->SetLastUsedPrinter(printerId);
604 }
605 
TestSendPrintJobEvent(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)606 void TestSendPrintJobEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
607 {
608     PrintJob jobInfo;
609     uint32_t jobStateArr[] = {PRINT_JOB_COMPLETED, PRINT_JOB_BLOCKED, PRINT_JOB_COMPLETED};
610     for (auto jobState : jobStateArr) {
611         jobInfo.SetJobState(jobState);
612         PrintServiceAbility::GetInstance()->SendPrintJobEvent(jobInfo);
613     }
614     uint32_t jobState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
615     jobInfo.SetJobState(jobState);
616     PrintServiceAbility::GetInstance()->SendPrintJobEvent(jobInfo);
617 }
618 
TestStartPrintJobCB(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)619 void TestStartPrintJobCB(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
620 {
621     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
622     auto printJob = std::make_shared<PrintJob>();
623     printJob->SetJobId(jobId);
624     printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
625     PrintServiceAbility::GetInstance()->StartPrintJobCB(jobId, printJob);
626 }
627 
TestCheckPrinterUriDifferent(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)628 void TestCheckPrinterUriDifferent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
629 {
630     auto printerInfo = std::make_shared<PrinterInfo>();
631     printerInfo->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
632     printerInfo->SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
633     printerInfo->SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
634     printerInfo->SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
635     PrintServiceAbility::GetInstance()->CheckPrinterUriDifferent(printerInfo);
636 }
637 
TestUpdatePrinterCapability(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)638 void TestUpdatePrinterCapability(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
639 {
640     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
641     PrinterInfo printerInfo;
642     printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
643     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
644     printerInfo.SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
645     printerInfo.SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
646     PrintServiceAbility::GetInstance()->UpdatePrinterCapability(printerId, printerInfo);
647 }
648 
TestReportCompletedPrint(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)649 void TestReportCompletedPrint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
650 {
651     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
652     PrintServiceAbility::GetInstance()->ReportCompletedPrint(printerId);
653 }
654 
TestReportHisysEvent(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)655 void TestReportHisysEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
656 {
657     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
658     auto printJob = std::make_shared<PrintJob>();
659     printJob->SetJobId(jobId);
660     printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
661     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
662     uint32_t subState = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
663     PrintServiceAbility::GetInstance()->ReportHisysEvent(printJob, printerId, subState);
664 }
665 
TestNotifyAppJobQueueChanged(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)666 void TestNotifyAppJobQueueChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
667 {
668     std::string applyResult = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
669     PrintServiceAbility::GetInstance()->NotifyAppJobQueueChanged(applyResult);
670 }
671 
TestSendPrinterChangeEvent(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)672 void TestSendPrinterChangeEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
673 {
674     int event = dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER);
675     PrinterInfo printerInfo;
676     printerInfo.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
677     printerInfo.SetPrinterName(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
678     printerInfo.SetDescription(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
679     printerInfo.SetPrinterState(dataProvider->ConsumeIntegralInRange<uint32_t>(0, MAX_SET_NUMBER));
680     PrintServiceAbility::GetInstance()->SendPrinterChangeEvent(event, printerInfo);
681     PrintServiceAbility::GetInstance()->DestroyExtension();
682     PrintServiceAbility::GetInstance()->ReduceAppCount();
683 }
684 
TestCheckJobQueueBlocked(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)685 void TestCheckJobQueueBlocked(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
686 {
687     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
688     PrintJob printJob;
689     printJob.SetJobId(jobId);
690     printJob.SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
691     PrintServiceAbility::GetInstance()->CheckJobQueueBlocked(printJob);
692 }
693 
TestGetListeningState(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)694 void TestGetListeningState(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
695 {
696     uint32_t subState = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
697     PrintServiceAbility::GetInstance()->GetListeningState(subState);
698 }
699 
TestChangeDefaultPrinterForDelete(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)700 void TestChangeDefaultPrinterForDelete(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
701 {
702     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
703     auto userData = std::make_shared<PrintUserData>();
704     PrintServiceAbility::GetInstance()->ChangeDefaultPrinterForDelete(userData, printerId);
705 }
706 
TestGetUserDataByUserId(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)707 void TestGetUserDataByUserId(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
708 {
709     int32_t userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
710     PrintServiceAbility::GetInstance()->GetUserDataByUserId(userId);
711 }
712 
TestDetermineUserJobStatus(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)713 void TestDetermineUserJobStatus(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
714 {
715     std::string jobId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
716     auto printJob = std::make_shared<PrintJob>();
717     printJob->SetJobId(jobId);
718     printJob->SetPrinterId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
719     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
720     std::map<std::string, std::shared_ptr<PrintJob>> jobList;
721     jobList[jobId] = printJob;
722     PrintServiceAbility::GetInstance()->DetermineUserJobStatus(jobList);
723 }
724 
TestNotifyCurrentUserChanged(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)725 void TestNotifyCurrentUserChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
726 {
727     int32_t userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
728     PrintServiceAbility::GetInstance()->NotifyCurrentUserChanged(userId);
729 }
730 
TestWriteEprinterPreference(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)731 void TestWriteEprinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
732 {
733     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
734     PrinterCapability printerCaps;
735     PrintPageSize pageSize;
736     pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
737     std::vector<PrintPageSize> pageSizeList;
738     pageSizeList.push_back(pageSize);
739     printerCaps.SetSupportedPageSize(pageSizeList);
740     PrintServiceAbility::GetInstance()->WriteEprinterPreference(printerId, printerCaps);
741 }
742 
TestWritePrinterPreference(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)743 void TestWritePrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
744 {
745     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
746     PrinterCapability printerCaps;
747     PrintPageSize pageSize;
748     pageSize.SetId(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
749     std::vector<PrintPageSize> pageSizeList;
750     pageSizeList.push_back(pageSize);
751     printerCaps.SetSupportedPageSize(pageSizeList);
752     printerCaps.SetOption(dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH));
753     PrintServiceAbility::GetInstance()->WritePrinterPreference(printerId, printerCaps);
754 }
755 
TestReadPreferenceFromFile(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)756 void TestReadPreferenceFromFile(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
757 {
758     std::string printerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
759     std::string printPreference = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
760     PrintServiceAbility::GetInstance()->ReadPreferenceFromFile(printerId, printPreference);
761 }
762 
TestMoreFunction(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)763 void TestMoreFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
764 {
765     TestChangeDefaultPrinterForDelete(data, size, dataProvider);
766     TestGetUserDataByUserId(data, size, dataProvider);
767     TestDetermineUserJobStatus(data, size, dataProvider);
768     TestNotifyCurrentUserChanged(data, size, dataProvider);
769     TestWriteEprinterPreference(data, size, dataProvider);
770     TestWritePrinterPreference(data, size, dataProvider);
771     TestReadPreferenceFromFile(data, size, dataProvider);
772 }
773 
TestNotPublicFunction(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)774 void TestNotPublicFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
775 {
776     TestDiscoverUsbPrinters(data, size, dataProvider);
777     TestStartNativePrintJob(data, size, dataProvider);
778     TestNotifyPrintServiceEvent(data, size, dataProvider);
779     TestUpdateQueuedJobList(data, size, dataProvider);
780     TestUpdatePrintJobOptionByPrinterId(data, size, dataProvider);
781     TestDelayStartDiscovery(data, size, dataProvider);
782     TestAdapterGetFileCallBack(data, size, dataProvider);
783     TestAddNativePrintJob(data, size, dataProvider);
784     TestIsQueuedJobListEmpty(data, size, dataProvider);
785     TestSetPrintJobCanceled(data, size, dataProvider);
786     TestCancelUserPrintJobs(data, size, dataProvider);
787     TestSendExtensionEvent(data, size, dataProvider);
788     TestNotifyAdapterJobChanged(data, size, dataProvider);
789     TestRegisterAdapterListener(data, size, dataProvider);
790     TestisEprint(data, size, dataProvider);
791     TestBuildPrinterPreferenceByOption(data, size, dataProvider);
792     TestBuildPrinterPreference(data, size, dataProvider);
793     TestBuildPrinterPreferenceByDefault(data, size, dataProvider);
794     TestBuildPrinterPreferenceByOption(data, size, dataProvider);
795     TestBuildPrinterAttrComponentByJson(data, size, dataProvider);
796     TestCheckIsDefaultPrinter(data, size, dataProvider);
797     TestCheckIsLastUsedPrinter(data, size, dataProvider);
798     TestSetLastUsedPrinter(data, size, dataProvider);
799     TestSendPrintJobEvent(data, size, dataProvider);
800     TestStartPrintJobCB(data, size, dataProvider);
801     TestCheckPrinterUriDifferent(data, size, dataProvider);
802     TestUpdatePrinterCapability(data, size, dataProvider);
803     TestReportCompletedPrint(data, size, dataProvider);
804     TestReportHisysEvent(data, size, dataProvider);
805     TestNotifyAppJobQueueChanged(data, size, dataProvider);
806     TestSendPrinterChangeEvent(data, size, dataProvider);
807     TestCheckJobQueueBlocked(data, size, dataProvider);
808     TestGetListeningState(data, size, dataProvider);
809     TestMoreFunction(data, size, dataProvider);
810 }
811 
812 }  // namespace Print
813 }  // namespace OHOS
814 
815 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)816 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
817 {
818     /* Run your code on data */
819     if (data == nullptr) {
820         return 0;
821     }
822 
823     if (size < OHOS::Print::U32_AT_SIZE) {
824     }
825 
826     FuzzedDataProvider dataProvider(data, size);
827     OHOS::Print::TestStartPrint(data, size, &dataProvider);
828     OHOS::Print::TestStopPrint(data, size, &dataProvider);
829     OHOS::Print::TestConnectPrinter(data, size, &dataProvider);
830     OHOS::Print::TestDisconnectPrinter(data, size, &dataProvider);
831     OHOS::Print::TestStartDiscoverPrinter(data, size, &dataProvider);
832     OHOS::Print::TestQueryAllExtension(data, size, &dataProvider);
833     OHOS::Print::TestStartPrintJob(data, size, &dataProvider);
834     OHOS::Print::TestCancelPrintJob(data, size, &dataProvider);
835     OHOS::Print::TestAddPrinters(data, size, &dataProvider);
836     OHOS::Print::TestRemovePrinters(data, size, &dataProvider);
837     OHOS::Print::TestUpdatePrinters(data, size, &dataProvider);
838     OHOS::Print::TestUpdatePrinterState(data, size, &dataProvider);
839     OHOS::Print::TestUpdatePrintJobStateOnlyForSystemApp(data, size, &dataProvider);
840     OHOS::Print::TestUpdateExtensionInfo(data, size, &dataProvider);
841     OHOS::Print::TestRequestPreview(data, size, &dataProvider);
842     OHOS::Print::TestQueryPrinterCapability(data, size, &dataProvider);
843     OHOS::Print::TestOn(data, size, &dataProvider);
844     OHOS::Print::TestOff(data, size, &dataProvider);
845     OHOS::Print::TestCallback(data, size, &dataProvider);
846     OHOS::Print::TestLoadExtSuccess(data, size, &dataProvider);
847     OHOS::Print::TestQueryAllPrintJob(data, size, &dataProvider);
848     OHOS::Print::TestQueryPrintJobById(data, size, &dataProvider);
849     OHOS::Print::TestAddPrinterToCups(data, size, &dataProvider);
850     OHOS::Print::TestQueryPrinterCapabilityByUri(data, size, &dataProvider);
851     OHOS::Print::TestPrintByAdapter(data, size, &dataProvider);
852     OHOS::Print::TestStartGetPrintFile(data, size, &dataProvider);
853     OHOS::Print::TestNotifyPrintService(data, size, &dataProvider);
854     OHOS::Print::TestQueryPrinterInfoByPrinterId(data, size, &dataProvider);
855     OHOS::Print::TestQueryAddedPrinter(data, size, &dataProvider);
856     OHOS::Print::TestQueryPrinterProperties(data, size, &dataProvider);
857     OHOS::Print::TestUpdatePrintJobState(data, size, &dataProvider);
858     OHOS::Print::TestGetPrinterPreference(data, size, &dataProvider);
859     OHOS::Print::TestSetPrinterPreference(data, size, &dataProvider);
860     OHOS::Print::TestSetDefaultPrinter(data, size, &dataProvider);
861     OHOS::Print::TestDeletePrinterFromCups(data, size, &dataProvider);
862     OHOS::Print::TestNotPublicFunction(data, size, &dataProvider);
863     return 0;
864 }
865