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 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
TestDiscoverUsbPrinters(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)403 void 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
TestStartNativePrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)415 void 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
TestNotifyPrintServiceEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)429 void 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
TestUpdateQueuedJobList(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)437 void 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
TestUpdatePrintJobOptionByPrinterId(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)447 void 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
TestDelayStartDiscovery(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)460 void 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
TestAdapterGetFileCallBack(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)466 void 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
TestAddNativePrintJob(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)474 void 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
TestIsQueuedJobListEmpty(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)481 void 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
TestSetPrintJobCanceled(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)487 void 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
TestCancelUserPrintJobs(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)495 void 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
TestSendExtensionEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)502 void 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
TestNotifyAdapterJobChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)510 void 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
TestRegisterAdapterListener(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)518 void 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
TestisEprint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)524 void 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
TestBuildPrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)532 void 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
TestBuildPrinterPreferenceByDefault(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)550 void 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
TestBuildPrinterPreferenceByOption(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)565 void 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
TestBuildPrinterAttrComponentByJson(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)575 void 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
TestCheckIsDefaultPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)592 void 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
TestCheckIsLastUsedPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)598 void 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
TestSetLastUsedPrinter(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)604 void 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
TestSendPrintJobEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)610 void 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
TestStartPrintJobCB(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)623 void 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
TestCheckPrinterUriDifferent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)632 void 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
TestUpdatePrinterCapability(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)642 void 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
TestReportCompletedPrint(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)653 void 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
TestReportHisysEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)659 void 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
TestNotifyAppJobQueueChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)670 void 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
TestSendPrinterChangeEvent(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)676 void 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
TestCheckJobQueueBlocked(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)689 void 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
TestGetListeningState(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)698 void 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
TestChangeDefaultPrinterForDelete(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)704 void 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
TestGetUserDataByUserId(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)711 void 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
TestDetermineUserJobStatus(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)717 void 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
TestNotifyCurrentUserChanged(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)729 void 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
TestWriteEprinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)735 void 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
TestWritePrinterPreference(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)747 void 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
TestReadPreferenceFromFile(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)760 void 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
TestMoreFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)767 void 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
TestNotPublicFunction(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)778 void 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 */
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)820 extern "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