1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <string>
18 #include <fstream>
19 #include <map>
20 #include "printer_info.h"
21 #define private public
22 #include "print_system_data.h"
23 #undef private
24 #include "print_log.h"
25 #include "print_constant.h"
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Print {
31
32 class PrintSystemDataTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void PrintSystemDataTest::SetUpTestCase(void) {}
41
TearDownTestCase(void)42 void PrintSystemDataTest::TearDownTestCase(void) {}
43
SetUp(void)44 void PrintSystemDataTest::SetUp(void)
45 {
46 static int32_t testNo = 0;
47 PRINT_HILOGI("PrintSystemDataTest_%{public}d", ++testNo);
48 }
49
TearDown(void)50 void PrintSystemDataTest::TearDown(void) {}
51
52 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0002, TestSize.Level1)
53 {
54 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
55 EXPECT_NE(systemData, nullptr);
56 std::string printerId = "1234";
57 CupsPrinterInfo cupsPrinterInfo;
58 systemData->InsertCupsPrinter(printerId, cupsPrinterInfo);
59 cupsPrinterInfo.name = "HUAWEI_PixLab_V1-0105";
60 cupsPrinterInfo.uri = "ipp://192.168.186.1:631/ipp/print";
61 cupsPrinterInfo.maker = "HUAWEI PixLab V1";
62 systemData->InsertCupsPrinter(printerId, cupsPrinterInfo);
63 std::map<std::string, std::shared_ptr<CupsPrinterInfo>> addedPrinterMap;
64 addedPrinterMap[printerId] = std::make_shared<CupsPrinterInfo>(cupsPrinterInfo);
65 EXPECT_EQ(addedPrinterMap.size(), 1);
66 }
67
68 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0004, TestSize.Level1)
69 {
70 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
71 EXPECT_NE(systemData, nullptr);
72 std::string printerName = "Direct Pixlab1620";
73 EXPECT_EQ(systemData->QueryPrinterIdByStandardizeName(printerName), "");
74 }
75
76 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0005, TestSize.Level1)
77 {
78 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
79 EXPECT_NE(systemData, nullptr);
80 std::string printerName = "Direct Pixlab1620";
81 EXPECT_EQ(systemData->QueryPrinterIdByStandardizeName(printerName), "");
82 std::string re = systemData->QueryPrinterIdByStandardizeName(printerName);
83 std::string printerId = "1234";
84 CupsPrinterInfo cupsPrinterInfo;
85 cupsPrinterInfo.name = "Direct Pixlab1620";
86 std::map<std::string, std::shared_ptr<CupsPrinterInfo>> addedPrinterMap;
87 addedPrinterMap[printerId] = std::make_shared<CupsPrinterInfo>(cupsPrinterInfo);
88 EXPECT_EQ(addedPrinterMap.size(), 1);
89 if (cupsPrinterInfo.name == printerName) {
90 re = printerId;
91 }
92 }
93
94 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0006, TestSize.Level1)
95 {
96 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
97 EXPECT_NE(systemData, nullptr);
98 std::string printerId = "1234";
99 CupsPrinterInfo cupsPrinterInfo1;
100 cupsPrinterInfo1.name = "Direct Pixlab1620";
101 CupsPrinterInfo cupsPrinterInfo2;
102 EXPECT_EQ(systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2), false);
103 std::map<std::string, std::shared_ptr<CupsPrinterInfo>> addedPrinterMap;
104 addedPrinterMap[printerId] = std::make_shared<CupsPrinterInfo>(cupsPrinterInfo1);
105 EXPECT_EQ(addedPrinterMap.size(), 1);
106 if (addedPrinterMap.count(printerId)) {
107 cupsPrinterInfo2 = cupsPrinterInfo1;
108 EXPECT_EQ(cupsPrinterInfo2.name, cupsPrinterInfo1.name);
109 }
110 }
111
112 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0007, TestSize.Level1)
113 {
114 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
115 EXPECT_NE(systemData, nullptr);
116 std::string printerId = "1234";
117 PrinterInfo printerInfo;
118 systemData->InsertPrinterInfo(printerId, printerInfo);
119 std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterInfoList;
120 addedPrinterInfoList[printerId] = std::make_shared<PrinterInfo>(printerInfo);
121 EXPECT_EQ(addedPrinterInfoList.size(), 1);
122 }
123
124 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0008, TestSize.Level1)
125 {
126 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
127 EXPECT_NE(systemData, nullptr);
128 std::string printerId = "1234";
129 EXPECT_EQ(systemData->QueryPrinterInfoByPrinterId(printerId), nullptr);
130 std::shared_ptr<PrinterInfo> result = std::make_shared<PrinterInfo>();
131 systemData->QueryPrinterInfoByPrinterId(printerId);
132 PrinterInfo printerInfo;
133 printerInfo.SetPrinterName("123");
134 std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterInfoList;
135 addedPrinterInfoList[printerId] = std::make_shared<PrinterInfo>(printerInfo);
136 EXPECT_EQ(addedPrinterInfoList.size(), 1);
137 if (addedPrinterInfoList.count(printerId)) {
138 result = addedPrinterInfoList[printerId];
139 EXPECT_EQ(result->GetPrinterName(), "123");
140 }
141 }
142
143 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0009, TestSize.Level1)
144 {
145 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
146 EXPECT_NE(systemData, nullptr);
147 Json::Value printerMapJson;
148 Json::Value printerJson;
149 printerJson["id"] = "com.ohos.spooler:mdns://9e9561ad-0e30-1000-8000-9c9561ad0e30";
150 printerJson["maker"] = "HUAWEI PixLab V1";
151 printerJson["name"] = "HUAWEI_PixLab_V1-0105";
152 printerJson["uri"] = "ipp://192.168.186.1:631/ipp/print";
153 printerMapJson.append(printerJson);
154 Json::Value jsonObject;
155 jsonObject["version"] = "v1";
156 jsonObject["printer_list"] = printerMapJson;
157 EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
158 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
159 }
160
161 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0010, TestSize.Level1)
162 {
163 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
164 EXPECT_NE(systemData, nullptr);
165 Json::Value printerMapJson;
166 printerMapJson["printer"] = "1234";
167 EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
168 printerMapJson["printer_list"] = "1234";
169 EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
170 }
171
172 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0011, TestSize.Level1)
173 {
174 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
175 EXPECT_NE(systemData, nullptr);
176 systemData->addedPrinterMap_.Insert("1", nullptr);
177 systemData->SavePrinterFile("1");
178 }
179
180 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0012, TestSize.Level1)
181 {
182 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
183 EXPECT_NE(systemData, nullptr);
184 systemData->addedPrinterMap_.Insert("1", nullptr);
185 std::string printerName = "Direct";
186 systemData->QueryPrinterIdByStandardizeName(printerName);
187 systemData->SavePrinterFile("1");
188 CupsPrinterInfo cupsPrinterInfo;
189 cupsPrinterInfo.name = "Direct";
190 cupsPrinterInfo.uri = "123";
191 cupsPrinterInfo.maker = "print";
192 systemData->addedPrinterMap_.Insert("2", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
193 systemData->QueryPrinterIdByStandardizeName(printerName);
194 cupsPrinterInfo.name = "223";
195 systemData->addedPrinterMap_.Insert("4", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
196 systemData->QueryPrinterIdByStandardizeName(printerName);
197 }
198
199 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0013, TestSize.Level1)
200 {
201 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
202 EXPECT_NE(systemData, nullptr);
203 std::string printerId = "1234";
204 CupsPrinterInfo cupsPrinterInfo2;
205 systemData->addedPrinterMap_.Insert("1", nullptr);
206 systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2);
207 systemData->SavePrinterFile("1");
208 CupsPrinterInfo cupsPrinterInfo;
209 cupsPrinterInfo.name = "Direct Pixlab1620";
210 cupsPrinterInfo.uri = "123";
211 cupsPrinterInfo.maker = "print";
212 systemData->addedPrinterMap_.Insert("123", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
213 CupsPrinterInfo cupsPrinterInfo3;
214 systemData->addedPrinterMap_.Insert("11", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo3));
215 systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2);
216 systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
217 systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2);
218 }
219
220 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0014, TestSize.Level1)
221 {
222 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
223 EXPECT_NE(systemData, nullptr);
224 std::string printerId = "1234";
225 PrinterInfo printerInfo;
226 systemData->InsertPrinterInfo(printerId, printerInfo);
227 systemData->addedPrinterMap_.Insert("1", nullptr);
228 systemData->InsertPrinterInfo(printerId, printerInfo);
229 }
230
231 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0015, TestSize.Level1)
232 {
233 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
234 EXPECT_NE(systemData, nullptr);
235 std::string printerId = "1234";
236 PrinterInfo printerInfo;
237 systemData->addedPrinterInfoList_["1"] = nullptr;
238 systemData->QueryPrinterInfoByPrinterId(printerId);
239 systemData->addedPrinterInfoList_["1234"] = std::make_shared<PrinterInfo>(printerInfo);
240 systemData->QueryPrinterInfoByPrinterId(printerId);
241 }
242
243 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0016, TestSize.Level1)
244 {
245 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
246 EXPECT_NE(systemData, nullptr);
247 std::string printerId = "1234";
248 CupsPrinterInfo cupsPrinterInfo;
249 systemData->InsertCupsPrinter(printerId, cupsPrinterInfo);
250 systemData->addedPrinterMap_.Insert("1234", nullptr);
251 systemData->InsertCupsPrinter(printerId, cupsPrinterInfo);
252 systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
253 systemData->InsertCupsPrinter(printerId, cupsPrinterInfo);
254 }
255
256 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0017, TestSize.Level1)
257 {
258 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
259 EXPECT_NE(systemData, nullptr);
260 Json::Value printerMapJson;
261 Json::Value printerJson;
262 printerJson["id"] = 123;
263 printerJson["maker"] = 123;
264 printerJson["name"] = 132;
265 printerJson["uri"] = 123;
266 printerMapJson.append(printerJson);
267 Json::Value jsonObject;
268 jsonObject["version"] = "v1";
269 jsonObject["printer_list"] = printerMapJson;
270 systemData->ParsePrinterListJsonV1(jsonObject);
271 }
272
273 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0018, TestSize.Level1)
274 {
275 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
276 EXPECT_NE(systemData, nullptr);
277 Json::Value printerMapJson;
278 Json::Value printerJson;
279 printerMapJson.append(printerJson);
280 Json::Value jsonObject;
281 jsonObject["version"] = "v1";
282 jsonObject["printer_list"] = printerMapJson;
283 systemData->ParsePrinterListJsonV1(jsonObject);
284
285 Json::Value printerJson2;
286 printerJson2["id"] = "123";
287 printerMapJson.append(printerJson2);
288 Json::Value jsonObject2;
289 jsonObject2["version"] = "v1";
290 jsonObject2["printer_list"] = printerMapJson;
291 systemData->ParsePrinterListJsonV1(jsonObject2);
292
293 Json::Value printerJson3;
294 printerJson3["id"] = "123";
295 printerJson3["name"] = 132;
296 printerMapJson.append(printerJson3);
297 Json::Value jsonObject3;
298 jsonObject3["version"] = "v1";
299 jsonObject3["printer_list"] = printerMapJson;
300 systemData->ParsePrinterListJsonV1(jsonObject3);
301
302 Json::Value printerJson4;
303 printerJson4["id"] = "123";
304 printerJson4["name"] = "132";
305 printerMapJson.append(printerJson4);
306 Json::Value jsonObject4;
307 jsonObject4["version"] = "v1";
308 jsonObject4["printer_list"] = printerMapJson;
309 systemData->ParsePrinterListJsonV1(jsonObject4);
310
311 Json::Value printerJson5;
312 printerJson5["id"] = "123";
313 printerJson5["name"] = "132";
314 printerJson5["uri"] = 123;
315 printerMapJson.append(printerJson5);
316 Json::Value jsonObject5;
317 jsonObject5["version"] = "v1";
318 jsonObject5["printer_list"] = printerMapJson;
319 systemData->ParsePrinterListJsonV1(jsonObject5);
320 }
321
322 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0019, TestSize.Level1)
323 {
324 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
325 EXPECT_NE(systemData, nullptr);
326 Json::Value printerMapJson;
327 Json::Value printerJson;
328 printerMapJson.append(printerJson);
329 Json::Value jsonObject;
330 jsonObject["version"] = "v1";
331 jsonObject["printer_list"] = printerMapJson;
332 systemData->ParsePrinterListJsonV1(jsonObject);
333
334 Json::Value printerJson6;
335 printerJson6["id"] = "123";
336 printerJson6["name"] = "132";
337 printerJson6["uri"] = "123";
338 printerMapJson.append(printerJson6);
339 Json::Value jsonObject6;
340 jsonObject6["version"] = "v1";
341 jsonObject6["printer_list"] = printerMapJson;
342 systemData->ParsePrinterListJsonV1(jsonObject6);
343
344 Json::Value printerJson7;
345 printerJson7["id"] = "123";
346 printerJson7["name"] = "132";
347 printerJson7["uri"] = "123";
348 printerJson7["maker"] = 123;
349 printerMapJson.append(printerJson7);
350 Json::Value jsonObject7;
351 jsonObject7["version"] = "v1";
352 jsonObject7["printer_list"] = printerMapJson;
353 systemData->ParsePrinterListJsonV1(jsonObject7);
354 }
355
356 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0020, TestSize.Level1)
357 {
358 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
359 EXPECT_NE(systemData, nullptr);
360 Json::Value printerMapJson;
361 Json::Value printerJson;
362 printerJson["id"] = "123";
363 printerJson["name"] = "132";
364 printerJson["uri"] = "123";
365 printerJson["maker"] = "123";
366 Json::Value capsJson;
367 printerJson["capability"] = capsJson;
368 printerMapJson.append(printerJson);
369 Json::Value jsonObject;
370 jsonObject["version"] = "v1";
371 jsonObject["printer_list"] = printerMapJson;
372 systemData->ParsePrinterListJsonV1(jsonObject);
373 }
374
375 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0021, TestSize.Level1)
376 {
377 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
378 EXPECT_NE(systemData, nullptr);
379 Json::Value printerMapJson;
380 Json::Value printerJson;
381 printerJson["id"] = "123";
382 printerJson["name"] = "132";
383 printerJson["uri"] = "123";
384 printerJson["maker"] = "123";
385 Json::Value capsJson;
386 printerJson["capability"] = capsJson;
387 printerMapJson.append(printerJson);
388 Json::Value jsonObject;
389 jsonObject["version"] = "v1";
390 jsonObject["printer_list"] = printerMapJson;
391 systemData->ParsePrinterListJsonV1(jsonObject);
392 }
393
394 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0022, TestSize.Level1)
395 {
396 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
397 EXPECT_NE(systemData, nullptr);
398 std::string printerId = "1234";
399 CupsPrinterInfo cupsPrinterInfo;
400 cupsPrinterInfo.alias = "test";
401 systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
402 systemData->InsertCupsPrinter(printerId, cupsPrinterInfo);
403 }
404
405 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0023, TestSize.Level1)
406 {
407 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
408 EXPECT_NE(systemData, nullptr);
409 std::string printerId = "1234";
410 std::string printerName = "1234";
411 CupsPrinterInfo cupsPrinterInfo;
412 systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
413 systemData->DeleteCupsPrinter(printerId, printerName);
414 }
415
416 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0024, TestSize.Level1)
417 {
418 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
419 EXPECT_NE(systemData, nullptr);
420 std::string printerId = "1234";
421 systemData->addedPrinterMap_.Insert("1", nullptr);
422 CupsPrinterInfo cupsPrinterInfo;
423 cupsPrinterInfo.name = "Direct";
424 cupsPrinterInfo.uri = "123";
425 cupsPrinterInfo.maker = "print";
426 systemData->addedPrinterMap_.Insert("2", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
427 CupsPrinterInfo cupsPrinterInfo2;
428 cupsPrinterInfo2.name = "Direct";
429 cupsPrinterInfo2.uri = "123";
430 cupsPrinterInfo2.maker = "print";
431 systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo2));
432 systemData->UpdatePrinterStatus(printerId, PRINTER_STATUS_IDLE);
433 }
434
435 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0025, TestSize.Level1)
436 {
437 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
438 EXPECT_NE(systemData, nullptr);
439 std::string printerId = "1234";
440 systemData->addedPrinterMap_.Insert("1", nullptr);
441 CupsPrinterInfo cupsPrinterInfo;
442 cupsPrinterInfo.name = "Direct";
443 cupsPrinterInfo.uri = "123";
444 cupsPrinterInfo.maker = "print";
445 systemData->addedPrinterMap_.Insert("2", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
446 std::vector<std::string> printerNameList;
447 systemData->GetAddedPrinterListFromSystemData(printerNameList);
448 }
449
450 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0026, TestSize.Level1)
451 {
452 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
453 EXPECT_NE(systemData, nullptr);
454 std::vector<std::string> printerNameList;
455 systemData->GetAddedPrinterListFromSystemData(printerNameList);
456 systemData->addedPrinterMap_.Insert("1", nullptr);
457 systemData->GetAddedPrinterListFromSystemData(printerNameList);
458 CupsPrinterInfo cupsPrinterInfo;
459 cupsPrinterInfo.name = "Direct";
460 cupsPrinterInfo.uri = "123";
461 cupsPrinterInfo.maker = "print";
462 systemData->addedPrinterMap_.Insert("1", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
463 systemData->GetAddedPrinterListFromSystemData(printerNameList);
464 }
465
466 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0027, TestSize.Level1)
467 {
468 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
469 EXPECT_NE(systemData, nullptr);
470 PrinterCapability printerCapability;
471 Json::Value capsJson;
472 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
473 }
474
475 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0028, TestSize.Level1)
476 {
477 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
478 EXPECT_NE(systemData, nullptr);
479 PrinterCapability printerCapability;
480 PrintMargin minMargin;
481 printerCapability.SetMinMargin(minMargin);
482 std::vector<PrintResolution> resolutionList;
483 printerCapability.SetResolution(resolutionList);
484 std::string ops = "test";
485 printerCapability.SetOption(ops);
486 Json::Value capsJson;
487 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
488 }
489
490 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0029, TestSize.Level1)
491 {
492 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
493 EXPECT_NE(systemData, nullptr);
494 PrinterCapability printerCapability;
495 PrintMargin minMargin;
496 printerCapability.SetMinMargin(minMargin);
497 std::vector<PrintResolution> resolutionList;
498 printerCapability.SetResolution(resolutionList);
499 Json::Value ops;
500 ops["key"] = "value";
501 printerCapability.SetOption(PrintJsonUtil::WriteString(ops));
502 Json::Value capsJson;
503 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
504 }
505
506 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0030, TestSize.Level1)
507 {
508 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
509 EXPECT_NE(systemData, nullptr);
510 PrinterCapability printerCapability;
511 PrintMargin minMargin;
512 printerCapability.SetMinMargin(minMargin);
513 Json::Value capsJson;
514 systemData->ConvertPrintMarginToJson(printerCapability, capsJson);
515 }
516
517 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0031, TestSize.Level1)
518 {
519 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
520 EXPECT_NE(systemData, nullptr);
521 PrinterCapability printerCapability;
522 PrintMargin minMargin;
523 minMargin.SetTop(100);
524 minMargin.SetBottom(100);
525 minMargin.SetLeft(100);
526 minMargin.SetRight(100);
527 printerCapability.SetMinMargin(minMargin);
528 Json::Value capsJson;
529 systemData->ConvertPrintMarginToJson(printerCapability, capsJson);
530 }
531
532 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0032, TestSize.Level1)
533 {
534 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
535 EXPECT_NE(systemData, nullptr);
536 Json::Value capsJson;
537 PrinterCapability printerCapability;
538 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
539 capsJson["colorMode"] = "string";
540 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
541 capsJson["colorMode"] = 123;
542 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
543 capsJson["duplexMode"] = "string";
544 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
545 capsJson["duplexMode"] = 123;
546 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
547 Json::Value marginJson;
548 capsJson["minMargin"] = marginJson;
549 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
550 Json::Value marginJson2;
551 capsJson["minMargin"] = marginJson2;
552 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
553 Json::Value pageSizeJson;
554 capsJson["pageSize"] = pageSizeJson;
555 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
556 Json::Value pageSizeJson2;
557 Json::Value pageSize;
558 pageSizeJson2.append(pageSize);
559 capsJson["pageSize"] = pageSizeJson2;
560 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
561 Json::Value pageSizeJson3;
562 capsJson["pageSize"] = pageSizeJson3;
563 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
564 Json::Value resolutionJson;
565 capsJson["resolution"] = resolutionJson;
566 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
567 Json::Value resolutionJson2;
568 Json::Value resolution;
569 resolutionJson2.append(resolution);
570 capsJson["resolution"] = resolutionJson2;
571 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
572 Json::Value resolutionJson3;
573 capsJson["resolution"] = resolutionJson3;
574 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
575 Json::Value opsJson;
576 capsJson["options"] = opsJson;
577 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
578 Json::Value opsJson2;
579 capsJson["options"] = opsJson2;
580 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
581 }
582
583 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0033, TestSize.Level1)
584 {
585 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
586 EXPECT_NE(systemData, nullptr);
587 Json::Value capsJson;
588 PrinterCapability printerCapability;
589 Json::Value resolutionListJson;
590 Json::Value resolutionItem;
591 resolutionListJson.append(resolutionItem);
592 capsJson["resolution"] = resolutionListJson;
593 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
594 Json::Value resolutionListJson2;
595 Json::Value resolutionItem2;
596 resolutionListJson2.append(resolutionItem2);
597 capsJson["resolution"] = resolutionListJson2;
598 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
599 Json::Value resolutionListJson3;
600 Json::Value resolutionItem3;
601 resolutionItem3["id"] = 123;
602 resolutionListJson3.append(resolutionItem3);
603 capsJson["resolution"] = resolutionListJson3;
604 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
605 Json::Value resolutionListJson4;
606 Json::Value resolutionItem4;
607 resolutionItem4["id"] = "123";
608 resolutionListJson4.append(resolutionItem4);
609 capsJson["resolution"] = resolutionListJson4;
610 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
611 }
612
613 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0034, TestSize.Level1)
614 {
615 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
616 EXPECT_NE(systemData, nullptr);
617 Json::Value capsJson;
618 PrinterCapability printerCapability;
619 Json::Value resolutionListJson;
620 Json::Value resolutionItem;
621 resolutionItem["id"] = "123";
622 resolutionItem["horizontalDpi"] = "123";
623 resolutionListJson.append(resolutionItem);
624 capsJson["resolution"] = resolutionListJson;
625 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
626 Json::Value resolutionListJson2;
627 Json::Value resolutionItem2;
628 resolutionItem2["id"] = "123";
629 resolutionItem2["horizontalDpi"] = 123;
630 resolutionListJson2.append(resolutionItem2);
631 capsJson["resolution"] = resolutionListJson2;
632 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
633 Json::Value resolutionListJson3;
634 Json::Value resolutionItem3;
635 resolutionItem3["id"] = "123";
636 resolutionItem3["horizontalDpi"] = 123;
637 resolutionItem3["verticalDpi"] = "123";
638 resolutionListJson3.append(resolutionItem3);
639 capsJson["resolution"] = resolutionListJson3;
640 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
641 Json::Value resolutionListJson4;
642 Json::Value resolutionItem4;
643 resolutionItem4["id"] = "123";
644 resolutionItem4["horizontalDpi"] = 123;
645 resolutionItem4["verticalDpi"] = 123;
646 resolutionListJson4.append(resolutionItem4);
647 capsJson["resolution"] = resolutionListJson4;
648 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
649 }
650
651 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0035, TestSize.Level1)
652 {
653 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
654 EXPECT_NE(systemData, nullptr);
655 Json::Value capsJson;
656 PrinterCapability printerCapability;
657 Json::Value resolutionListJson;
658 capsJson["resolution"] = resolutionListJson;
659 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
660 }
661
662 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0036, TestSize.Level1)
663 {
664 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
665 EXPECT_NE(systemData, nullptr);
666 Json::Value capsJson;
667 PrinterCapability printerCapability;
668 Json::Value pageSizeListJson;
669 capsJson["pageSize"] = pageSizeListJson;
670 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
671
672 Json::Value pageSizeListJson2;
673 Json::Value pageSizeItem2;
674 pageSizeListJson2.append(pageSizeItem2);
675 capsJson["pageSize"] = pageSizeListJson2;
676 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
677
678 Json::Value pageSizeListJson3;
679 Json::Value pageSizeItem3;
680 pageSizeItem3["id"] = 123;
681 pageSizeListJson3.append(pageSizeItem3);
682 capsJson["pageSize"] = pageSizeListJson3;
683 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
684
685 Json::Value pageSizeListJson4;
686 Json::Value pageSizeItem4;
687 pageSizeItem4["id"] = "123";
688 pageSizeListJson4.append(pageSizeItem4);
689 capsJson["pageSize"] = pageSizeListJson4;
690 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
691 }
692
693 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0037, TestSize.Level1)
694 {
695 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
696 EXPECT_NE(systemData, nullptr);
697 Json::Value capsJson;
698 PrinterCapability printerCapability;
699 Json::Value pageSizeListJson;
700 Json::Value pageSizeItem;
701 pageSizeItem["id"] = "123";
702 pageSizeItem["name"] = 123;
703 pageSizeListJson.append(pageSizeItem);
704 capsJson["pageSize"] = pageSizeListJson;
705 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
706
707 Json::Value pageSizeListJson2;
708 Json::Value pageSizeItem2;
709 pageSizeItem2["id"] = "123";
710 pageSizeItem2["name"] = "123";
711 pageSizeListJson2.append(pageSizeItem2);
712 capsJson["pageSize"] = pageSizeListJson2;
713 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
714
715 Json::Value pageSizeListJson3;
716 Json::Value pageSizeItem3;
717 pageSizeItem3["id"] = "123";
718 pageSizeItem3["name"] = "123";
719 pageSizeItem3["width"] = "123";
720 pageSizeListJson3.append(pageSizeItem3);
721 capsJson["pageSize"] = pageSizeListJson3;
722 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
723
724 Json::Value pageSizeListJson4;
725 Json::Value pageSizeItem4;
726 pageSizeItem4["id"] = "123";
727 pageSizeItem4["name"] = "123";
728 pageSizeItem4["width"] = 123;
729 pageSizeListJson4.append(pageSizeItem4);
730 capsJson["pageSize"] = pageSizeListJson4;
731 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
732 }
733
734 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0038, TestSize.Level1)
735 {
736 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
737 EXPECT_NE(systemData, nullptr);
738 Json::Value capsJson;
739 PrinterCapability printerCapability;
740 Json::Value pageSizeListJson;
741 Json::Value pageSizeItem;
742 pageSizeItem["id"] = "123";
743 pageSizeItem["name"] = "123";
744 pageSizeItem["width"] = 123;
745 pageSizeItem["height"] = "123";
746 pageSizeListJson.append(pageSizeItem);
747 capsJson["pageSize"] = pageSizeListJson;
748 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
749
750 Json::Value pageSizeListJson2;
751 Json::Value pageSizeItem2;
752 pageSizeItem2["id"] = "123";
753 pageSizeItem2["name"] = "123";
754 pageSizeItem2["width"] = 123;
755 pageSizeItem2["height"] = 123;
756 pageSizeListJson2.append(pageSizeItem2);
757 capsJson["pageSize"] = pageSizeListJson2;
758 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
759 }
760
761 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0039, TestSize.Level1)
762 {
763 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
764 EXPECT_NE(systemData, nullptr);
765 Json::Value capsJson;
766 PrinterCapability printerCapability;
767 Json::Value marginJson;
768 capsJson["minMargin"] = marginJson;
769 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
770
771 Json::Value marginJson2;
772 marginJson2["top"] = "123";
773 capsJson["minMargin"] = marginJson2;
774 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
775
776 Json::Value marginJson3;
777 marginJson3["top"] = 123;
778 capsJson["minMargin"] = marginJson3;
779 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
780
781 Json::Value marginJson4;
782 marginJson4["top"] = 123;
783 marginJson4["bottom"] = "123";
784 capsJson["minMargin"] = marginJson4;
785 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
786
787 Json::Value marginJson5;
788 marginJson5["top"] = 123;
789 marginJson5["bottom"] = 123;
790 capsJson["minMargin"] = marginJson5;
791 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
792
793 Json::Value marginJson6;
794 marginJson6["top"] = 123;
795 marginJson6["bottom"] = 123;
796 marginJson6["left"] = "123";
797 capsJson["minMargin"] = marginJson6;
798 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
799
800 Json::Value marginJson7;
801 marginJson7["top"] = 123;
802 marginJson7["bottom"] = 123;
803 marginJson7["left"] = 123;
804 capsJson["minMargin"] = marginJson7;
805 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
806 }
807
808 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0040, TestSize.Level1)
809 {
810 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
811 EXPECT_NE(systemData, nullptr);
812 Json::Value capsJson;
813 PrinterCapability printerCapability;
814 Json::Value marginJson;
815 marginJson["top"] = 123;
816 marginJson["bottom"] = 123;
817 marginJson["left"] = 123;
818 marginJson["right"] = "123";
819 capsJson["minMargin"] = marginJson;
820 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
821
822 Json::Value marginJson2;
823 marginJson2["top"] = 123;
824 marginJson2["bottom"] = 123;
825 marginJson2["left"] = 123;
826 marginJson2["right"] = 123;
827 capsJson["minMargin"] = marginJson2;
828 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
829 }
830
831 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0041, TestSize.Level1)
832 {
833 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
834 EXPECT_NE(systemData, nullptr);
835 CupsPrinterInfo cupsPrinter;
836 std::string printerId = "123";
837 PrinterCapability printerCapability;
838 systemData->GetPrinterCapabilityFromSystemData(cupsPrinter, printerId, printerCapability);
839 }
840
841 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0042, TestSize.Level1)
842 {
843 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
844 EXPECT_NE(systemData, nullptr);
845 CupsPrinterInfo cupsPrinter;
846 std::string printerId = "123";
847 PrinterCapability printerCapability;
848 PrinterCapability printerCapability2;
849 Json::Value opsJson;
850 opsJson["key"] = "value";
851 printerCapability2.SetOption(PrintJsonUtil::WriteString(opsJson));
852 std::vector<PrintPageSize> pageSizeList;
853 PrintPageSize pageSize;
854 pageSizeList.push_back(pageSize);
855 printerCapability2.SetSupportedPageSize(pageSizeList);
856 cupsPrinter.printerCapability = printerCapability2;
857 systemData->GetPrinterCapabilityFromSystemData(cupsPrinter, printerId, printerCapability);
858 }
859
860 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0043, TestSize.Level1)
861 {
862 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
863 EXPECT_NE(systemData, nullptr);
864 Json::Value object;
865 std::string printerId = "123";
866 systemData->CheckPrinterInfoJson(object, printerId);
867 }
868
869 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0044, TestSize.Level1)
870 {
871 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
872 EXPECT_NE(systemData, nullptr);
873 Json::Value object;
874 object["id"] = 123;
875 std::string printerId = "123";
876 systemData->CheckPrinterInfoJson(object, printerId);
877
878 Json::Value object2;
879 object2["id"] = "12";
880 systemData->CheckPrinterInfoJson(object2, printerId);
881
882 Json::Value object3;
883 object3["id"] = "123";
884 systemData->CheckPrinterInfoJson(object3, printerId);
885
886 Json::Value object4;
887 object4["id"] = "123";
888 object4["name"] = 123;
889 systemData->CheckPrinterInfoJson(object4, printerId);
890
891 Json::Value object5;
892 object5["id"] = "123";
893 object5["name"] = "123";
894 systemData->CheckPrinterInfoJson(object5, printerId);
895
896 Json::Value object6;
897 object6["id"] = "123";
898 object6["name"] = "123";
899 object6["uri"] = 123;
900 systemData->CheckPrinterInfoJson(object6, printerId);
901
902 Json::Value object7;
903 object7["id"] = "123";
904 object7["name"] = "123";
905 object7["uri"] = "123";
906 systemData->CheckPrinterInfoJson(object7, printerId);
907 }
908
909 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0045, TestSize.Level1)
910 {
911 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
912 EXPECT_NE(systemData, nullptr);
913 Json::Value object;
914 object["id"] = "123";
915 object["name"] = "123";
916 object["uri"] = "123";
917 object["maker"] = 123;
918 std::string printerId = "123";
919 systemData->CheckPrinterInfoJson(object, printerId);
920
921 Json::Value object2;
922 object2["id"] = "123";
923 object2["name"] = "123";
924 object2["uri"] = "123";
925 object2["maker"] = "123";
926 systemData->CheckPrinterInfoJson(object2, printerId);
927
928 Json::Value object3;
929 object3["id"] = "123";
930 object3["name"] = "123";
931 object3["uri"] = "123";
932 object3["maker"] = "123";
933 object3["capability"] = "123";
934 systemData->CheckPrinterInfoJson(object3, printerId);
935
936 Json::Value object4;
937 object4["id"] = "123";
938 object4["name"] = "123";
939 object4["uri"] = "123";
940 object4["maker"] = "123";
941 Json::Value capsJson;
942 object4["capability"] = capsJson;
943 systemData->CheckPrinterInfoJson(object4, printerId);
944 }
945
946 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0046, TestSize.Level1)
947 {
948 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
949 EXPECT_NE(systemData, nullptr);
950 std::string printerId = "123";
951 systemData->IsPrinterAdded(printerId);
952 systemData->addedPrinterMap_.Insert("123", nullptr);
953 systemData->IsPrinterAdded(printerId);
954 CupsPrinterInfo cupsPrinterInfo;
955 cupsPrinterInfo.name = "Direct";
956 cupsPrinterInfo.uri = "123";
957 cupsPrinterInfo.maker = "print";
958 systemData->addedPrinterMap_.Insert("123", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
959 systemData->IsPrinterAdded(printerId);
960 }
961
962 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0047, TestSize.Level1)
963 {
964 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
965 EXPECT_NE(systemData, nullptr);
966 std::string printerId = "1234";
967 PrinterInfo printerInfo;
968 systemData->QueryPrinterInfoById(printerId, printerInfo);
969 CupsPrinterInfo cupsPrinterInfo;
970 cupsPrinterInfo.name = "Direct Pixlab1620";
971 cupsPrinterInfo.uri = "123";
972 cupsPrinterInfo.maker = "print";
973 systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
974 systemData->QueryPrinterInfoById(printerId, printerInfo);
975 }
976
977 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0048, TestSize.Level1)
978 {
979 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
980 EXPECT_NE(systemData, nullptr);
981 std::string printerId;
982 Json::Value jsonObject;
983 PrinterCapability printerCapability;
984 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
985
986 Json::Value printerMapJson;
987 jsonObject["printer_list"] = printerMapJson;
988 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
989
990 Json::Value jsonObject2;
991 Json::Value printerMapJson2;
992 jsonObject2["printer_list"] = printerMapJson2;
993 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject2, printerCapability);
994
995 Json::Value jsonObject3;
996 Json::Value printerMapJson3;
997 Json::Value item;
998 item["key"] = "value";
999 printerMapJson3.append(item);
1000 jsonObject3["printer_list"] = printerMapJson3;
1001 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject3, printerCapability);
1002 }
1003
1004 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0049, TestSize.Level1)
1005 {
1006 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1007 EXPECT_NE(systemData, nullptr);
1008 std::string printerId;
1009 PrinterCapability printerCapability;
1010 Json::Value jsonObject;
1011 Json::Value printerMapJson;
1012 Json::Value item;
1013 item["id"] = "123";
1014 item["name"] = "123";
1015 item["uri"] = "123";
1016 item["maker"] = "123";
1017 Json::Value capsJson;
1018 capsJson["key"] = "value";
1019 item["capability"] = capsJson;
1020 printerMapJson.append(item);
1021 jsonObject["printer_list"] = printerMapJson;
1022 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1023 }
1024
1025 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0050, TestSize.Level1)
1026 {
1027 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1028 EXPECT_NE(systemData, nullptr);
1029 std::string printerId;
1030 PrinterCapability printerCapability;
1031 Json::Value jsonObject;
1032 Json::Value printerMapJson;
1033 Json::Value item;
1034 item["id"] = "123";
1035 item["name"] = "123";
1036 item["uri"] = "123";
1037 item["maker"] = "123";
1038 Json::Value capsJson;
1039 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
1040 item["capability"] = capsJson;
1041 printerMapJson.append(item);
1042 jsonObject["printer_list"] = printerMapJson;
1043 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1044 }
1045
1046 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0051, TestSize.Level1)
1047 {
1048 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1049 EXPECT_NE(systemData, nullptr);
1050 std::string printerId = "123";
1051 PrinterCapability printerCapability;
1052 std::vector<PrintPageSize> pageSizeList;
1053 PrintPageSize pageSize;
1054 pageSizeList.push_back(pageSize);
1055 printerCapability.SetSupportedPageSize(pageSizeList);
1056 Json::Value opsJson;
1057 opsJson["printerName"] = "123";
1058 printerCapability.SetOption(PrintJsonUtil::WriteString(opsJson));
1059 Json::Value jsonObject;
1060 Json::Value printerMapJson;
1061 Json::Value item;
1062 item["id"] = "123";
1063 item["name"] = "123";
1064 item["uri"] = "123";
1065 item["maker"] = "123";
1066 Json::Value capsJson;
1067 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
1068 item["capability"] = capsJson;
1069 printerMapJson.append(item);
1070 jsonObject["printer_list"] = printerMapJson;
1071 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1072 }
1073
1074 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0052, TestSize.Level1)
1075 {
1076 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1077 EXPECT_NE(systemData, nullptr);
1078 std::string printerId = "";
1079 std::string printerName = "";
1080 systemData->DeleteCupsPrinter(printerId, printerName);
1081 }
1082
1083 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0053, TestSize.Level1)
1084 {
1085 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1086 EXPECT_NE(systemData, nullptr);
1087 std::string printerId = "1234";
1088 std::string printerAlias = "1234";
1089 systemData->UpdatePrinterAlias(printerId, printerAlias);
1090
1091 CupsPrinterInfo cupsPrinterInfo;
1092 cupsPrinterInfo.alias = printerAlias;
1093 systemData->addedPrinterMap_.Insert(printerId, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
1094
1095 bool ret = systemData->UpdatePrinterAlias(printerId, "");
1096 EXPECT_EQ(ret, true);
1097
1098 systemData->UpdatePrinterAlias(printerId, printerAlias);
1099 }
1100
1101 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0054, TestSize.Level1)
1102 {
1103 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1104 EXPECT_NE(systemData, nullptr);
1105 std::string printerId1 = "1";
1106 CupsPrinterInfo cupsPrinterInfo1;
1107 systemData->addedPrinterMap_.Insert(printerId1, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo1));
1108 systemData->CheckPrinterBusy(printerId1);
1109
1110 std::string printerId2 = "2";
1111 CupsPrinterInfo cupsPrinterInfo2;
1112 cupsPrinterInfo2.printerStatus = PRINTER_STATUS_BUSY;
1113 systemData->addedPrinterMap_.Insert(printerId2, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo2));
1114 bool ret = systemData->CheckPrinterBusy(printerId2);
1115 EXPECT_EQ(ret, true);
1116 }
1117
1118 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0055, TestSize.Level1)
1119 {
1120 auto systemData = std::make_shared<PrintSystemData>();
1121 EXPECT_NE(systemData, nullptr);
1122 std::string printerId1 = "1";
1123 std::string printerId2 = "2";
1124 std::string printerName = "name";
1125 auto printerInfo = std::make_shared<PrinterInfo>();
1126 EXPECT_NE(printerInfo, nullptr);
1127 printerInfo->SetPrinterId(printerId1);
1128 printerInfo->SetPrinterName(printerName);
1129 systemData->AddPrinterToDiscovery(printerInfo);
1130 EXPECT_EQ(systemData->GetDiscoveredPrinterCount(), 1);
1131 auto discoveredPrinter = systemData->QueryDiscoveredPrinterInfoById(printerId1);
1132 EXPECT_NE(discoveredPrinter, nullptr);
1133 discoveredPrinter = systemData->QueryDiscoveredPrinterInfoById(printerId2);
1134 EXPECT_EQ(discoveredPrinter, nullptr);
1135 discoveredPrinter = systemData->QueryDiscoveredPrinterInfoByName(printerName);
1136 EXPECT_NE(discoveredPrinter, nullptr);
1137 discoveredPrinter = systemData->QueryDiscoveredPrinterInfoByName(printerId2);
1138 EXPECT_EQ(discoveredPrinter, nullptr);
1139 systemData->RemovePrinterFromDiscovery(printerId1);
1140 EXPECT_EQ(systemData->GetDiscoveredPrinterCount(), 0);
1141 systemData->ClearDiscoveredPrinterList();
1142 }
1143
1144 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0056, TestSize.Level1) {
1145 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1146 EXPECT_NE(systemData, nullptr);
1147 PrinterCapability printerCapability;
1148 std::vector<uint32_t> supportedColorModeList;
1149 supportedColorModeList.push_back(1);
1150 printerCapability.SetSupportedColorMode(supportedColorModeList);
1151 Json::Value capsJson;
1152 systemData->ConvertSupportedColorModeToJson(printerCapability, capsJson);
1153 }
1154
1155 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0057, TestSize.Level1) {
1156 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1157 EXPECT_NE(systemData, nullptr);
1158 PrinterCapability printerCapability;
1159 std::vector<uint32_t> supportedDuplexModeList;
1160 supportedDuplexModeList.push_back(1);
1161 printerCapability.SetSupportedDuplexMode(supportedDuplexModeList);
1162 Json::Value capsJson;
1163 systemData->ConvertSupportedDuplexModeToJson(printerCapability, capsJson);
1164 }
1165
1166 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0058, TestSize.Level1) {
1167 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1168 EXPECT_NE(systemData, nullptr);
1169 PrinterCapability printerCapability;
1170 std::vector<std::string> supportedMediaTypeList;
1171 supportedMediaTypeList.push_back("type1");
1172 printerCapability.SetSupportedMediaType(supportedMediaTypeList);
1173 Json::Value capsJson;
1174 systemData->ConvertSupportedMediaTypeToJson(printerCapability, capsJson);
1175 }
1176
1177 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0059, TestSize.Level1) {
1178 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1179 EXPECT_NE(systemData, nullptr);
1180 PrinterCapability printerCapability;
1181 std::vector<uint32_t> supportedQualityList;
1182 supportedQualityList.push_back(1);
1183 printerCapability.SetSupportedQuality(supportedQualityList);
1184 Json::Value capsJson;
1185 systemData->ConvertSupportedQualityToJson(printerCapability, capsJson);
1186 }
1187
1188 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0060, TestSize.Level1)
1189 {
1190 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1191 EXPECT_NE(systemData, nullptr);
1192 CupsPrinterInfo info;
1193 Json::Value printerJson;
1194 systemData->ConvertInnerJsonToCupsPrinterInfo(printerJson, info);
1195 printerJson["alias"] = 123;
1196 printerJson["printerStatus"] = "132";
1197 printerJson["preferences"] = "123";
1198 systemData->ConvertInnerJsonToCupsPrinterInfo(printerJson, info);
1199 printerJson["alias"] = "123";
1200 printerJson["printerStatus"] = 123;
1201 Json::Value preferencesJson;
1202 printerJson["preferences"] = preferencesJson;
1203 systemData->ConvertInnerJsonToCupsPrinterInfo(printerJson, info);
1204 EXPECT_EQ(info.alias, printerJson["alias"].asString());
1205 EXPECT_EQ(info.printerStatus, static_cast<PrinterStatus>(printerJson["printerStatus"].asInt()));
1206 }
1207
1208 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0061, TestSize.Level1)
1209 {
1210 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1211 EXPECT_NE(systemData, nullptr);
1212 Json::Value jsonObject;
1213 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), false);
1214 }
1215
1216 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0062, TestSize.Level1)
1217 {
1218 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1219 EXPECT_NE(systemData, nullptr);
1220 PrinterPreferences preferences;
1221 Json::Value settingJson;
1222 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), false);
1223 }
1224
1225 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0063, TestSize.Level1)
1226 {
1227 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1228 EXPECT_NE(systemData, nullptr);
1229 PrinterPreferences preferences;
1230 Json::Value settingJson;
1231 settingJson["pagesizeId"] = 123;
1232 settingJson["orientation"] = 123;
1233 settingJson["duplex"] = 123;
1234 settingJson["quality"] = 123;
1235 settingJson["mediaType"] = 123;
1236 settingJson["hasMargin"] = "123";
1237 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), false);
1238 }
1239
1240 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0064, TestSize.Level1)
1241 {
1242 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1243 EXPECT_NE(systemData, nullptr);
1244 PrinterPreferences preferences;
1245 Json::Value settingJson;
1246 settingJson["pagesizeId"] = "";
1247 settingJson["orientation"] = "";
1248 settingJson["duplex"] = "";
1249 settingJson["quality"] = "";
1250 settingJson["mediaType"] = "";
1251 settingJson["hasMargin"] = true;
1252 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), false);
1253 }
1254
1255 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0065, TestSize.Level1)
1256 {
1257 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1258 EXPECT_NE(systemData, nullptr);
1259 PrinterPreferences preferences;
1260 Json::Value settingJson;
1261 settingJson["pagesizeId"] = "123";
1262 settingJson["orientation"] = "123";
1263 settingJson["duplex"] = "123";
1264 settingJson["quality"] = "123";
1265 settingJson["mediaType"] = "123";
1266 settingJson["hasMargin"] = false;
1267 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), true);
1268 }
1269
1270 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0066, TestSize.Level1)
1271 {
1272 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1273 EXPECT_NE(systemData, nullptr);
1274 std::string printerId = "1234";
1275 PrinterPreferences preferences;
1276 preferences.SetBorderless(true);
1277 systemData->UpdatePrinterPreferences(printerId, preferences);
1278
1279 CupsPrinterInfo cupsPrinterInfo;
1280 cupsPrinterInfo.printPreferences = preferences;
1281 systemData->addedPrinterMap_.Insert(printerId, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
1282 systemData->UpdatePrinterPreferences(printerId, preferences);
1283 CupsPrinterInfo cupsPrinter;
1284 systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinter);
1285 EXPECT_EQ(cupsPrinter.printPreferences.GetBorderless(), preferences.GetBorderless());
1286 }
1287
1288 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0070, TestSize.Level1)
1289 {
1290 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1291 EXPECT_NE(systemData, nullptr);
1292 PrinterPreferences preferences;
1293 PrinterCapability cap;
1294 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_INVALID_PRINTER);
1295 }
1296
1297 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0071, TestSize.Level1)
1298 {
1299 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1300 EXPECT_NE(systemData, nullptr);
1301 PrinterPreferences preferences;
1302 PrinterCapability cap;
1303 cap.SetOption("test");
1304 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_INVALID_PARAMETER);
1305 }
1306
1307 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0072, TestSize.Level1)
1308 {
1309 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1310 EXPECT_NE(systemData, nullptr);
1311 PrinterPreferences preferences;
1312 PrinterCapability cap;
1313 Json::Value optionJson;
1314 optionJson["key"] = "value";
1315 cap.SetOption(PrintJsonUtil::WriteString(optionJson));
1316 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_INVALID_PARAMETER);
1317 }
1318
1319 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0073, TestSize.Level1)
1320 {
1321 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1322 EXPECT_NE(systemData, nullptr);
1323 PrinterPreferences preferences;
1324 PrinterCapability cap;
1325 Json::Value optionJson;
1326 optionJson["cupsOptions"] = "value";
1327 cap.SetOption(PrintJsonUtil::WriteString(optionJson));
1328 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_NONE);
1329 }
1330
1331 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0074, TestSize.Level1)
1332 {
1333 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1334 EXPECT_NE(systemData, nullptr);
1335 PrinterCapability cap;
1336 Json::Value capOpt;
1337 EXPECT_EQ(systemData->ParseDefaultPageSizeId(cap, capOpt), "");
1338 }
1339
1340 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0075, TestSize.Level1)
1341 {
1342 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1343 EXPECT_NE(systemData, nullptr);
1344 PrinterCapability cap;
1345 Json::Value capOpt;
1346 capOpt["defaultPageSizeId"] = 123;
1347 std::vector<PrintPageSize> supportedPageSize;
1348 PrintPageSize pageSize1;
1349 pageSize1.SetId("ISO_A3");
1350 PrintPageSize pageSize2;
1351 pageSize2.SetId("ISO_A4");
1352 supportedPageSize.emplace_back(pageSize1);
1353 supportedPageSize.emplace_back(pageSize2);
1354 cap.SetSupportedPageSize(supportedPageSize);
1355 EXPECT_EQ(systemData->ParseDefaultPageSizeId(cap, capOpt), "ISO_A3");
1356 }
1357
1358 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0076, TestSize.Level1)
1359 {
1360 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1361 EXPECT_NE(systemData, nullptr);
1362 PrinterCapability cap;
1363 Json::Value capOpt;
1364 capOpt["defaultPageSizeId"] = "123";
1365 EXPECT_EQ(systemData->ParseDefaultPageSizeId(cap, capOpt), "123");
1366 }
1367
1368 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0077, TestSize.Level1)
1369 {
1370 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1371 EXPECT_NE(systemData, nullptr);
1372 PrinterCapability cap;
1373 Json::Value capOpt;
1374 EXPECT_EQ(systemData->ParseDefaultOrientation(cap, capOpt), 0);
1375 }
1376
1377 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0078, TestSize.Level1)
1378 {
1379 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1380 EXPECT_NE(systemData, nullptr);
1381 PrinterCapability cap;
1382 Json::Value capOpt;
1383 capOpt["orientation-requested-default"] = 123;
1384 EXPECT_EQ(systemData->ParseDefaultOrientation(cap, capOpt), 0);
1385 }
1386
1387 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0079, TestSize.Level1)
1388 {
1389 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1390 EXPECT_NE(systemData, nullptr);
1391 PrinterCapability cap;
1392 Json::Value capOpt;
1393 capOpt["orientation-requested-default"] = "0";
1394 EXPECT_EQ(systemData->ParseDefaultOrientation(cap, capOpt), 0);
1395 }
1396
1397 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0080, TestSize.Level1)
1398 {
1399 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1400 EXPECT_NE(systemData, nullptr);
1401 PrinterCapability cap;
1402 Json::Value capOpt;
1403 EXPECT_EQ(systemData->ParseDefaultDuplexMode(cap, capOpt), 0);
1404 }
1405
1406 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0081, TestSize.Level1)
1407 {
1408 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1409 EXPECT_NE(systemData, nullptr);
1410 PrinterCapability cap;
1411 Json::Value capOpt ;
1412 capOpt["sides-default"] = 123;
1413 std::vector<uint32_t> supportedDuplexModeList;
1414 supportedDuplexModeList.emplace_back(2);
1415 cap.SetSupportedDuplexMode(supportedDuplexModeList);
1416 EXPECT_EQ(systemData->ParseDefaultDuplexMode(cap, capOpt), 2);
1417 }
1418
1419 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0082, TestSize.Level1)
1420 {
1421 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1422 EXPECT_NE(systemData, nullptr);
1423 PrinterCapability cap;
1424 Json::Value capOpt;
1425 capOpt["sides-default"] = 123;
1426 std::vector<uint32_t> supportedDuplexModeList;
1427 supportedDuplexModeList.emplace_back(0);
1428 cap.SetSupportedDuplexMode(supportedDuplexModeList);
1429 EXPECT_EQ(systemData->ParseDefaultDuplexMode(cap, capOpt), 0);
1430 }
1431
1432 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0083, TestSize.Level1)
1433 {
1434 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1435 EXPECT_NE(systemData, nullptr);
1436 PrinterCapability cap;
1437 Json::Value capOpt;
1438 capOpt["sides-default"] = "0";
1439 EXPECT_EQ(systemData->ParseDefaultDuplexMode(cap, capOpt), 0);
1440 }
1441
1442 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0084, TestSize.Level1)
1443 {
1444 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1445 EXPECT_NE(systemData, nullptr);
1446 PrinterCapability cap;
1447 Json::Value capOpt;
1448 EXPECT_EQ(systemData->ParseDefaultPrintQuality(cap, capOpt), 0);
1449 }
1450
1451 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0085, TestSize.Level1)
1452 {
1453 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1454 EXPECT_NE(systemData, nullptr);
1455 PrinterCapability cap;
1456 Json::Value capOpt;
1457 capOpt["print-quality-default"] = 123;
1458 std::vector<uint32_t> supportedQualityList;
1459 supportedQualityList.emplace_back(2);
1460 supportedQualityList.emplace_back(4);
1461 cap.SetSupportedQuality(supportedQualityList);
1462 EXPECT_EQ(systemData->ParseDefaultPrintQuality(cap, capOpt), 4);
1463 }
1464
1465 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0086, TestSize.Level1)
1466 {
1467 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1468 EXPECT_NE(systemData, nullptr);
1469 PrinterCapability cap;
1470 Json::Value capOpt;
1471 capOpt["print-quality-default"] = "4";
1472 EXPECT_EQ(systemData->ParseDefaultPrintQuality(cap, capOpt), 4);
1473 }
1474
1475 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0087, TestSize.Level1)
1476 {
1477 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1478 EXPECT_NE(systemData, nullptr);
1479 PrinterCapability cap;
1480 Json::Value capOpt;
1481 EXPECT_EQ(systemData->ParseDefaultMediaType(cap, capOpt), "");
1482 }
1483
1484 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0088, TestSize.Level1)
1485 {
1486 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1487 EXPECT_NE(systemData, nullptr);
1488 PrinterCapability cap;
1489 Json::Value capOpt;
1490 capOpt["media-type-default"] = 123;
1491 std::vector<std::string> supportedMediaTypeList;
1492 supportedMediaTypeList.emplace_back("photo");
1493 supportedMediaTypeList.emplace_back("stationery");
1494 cap.SetSupportedMediaType(supportedMediaTypeList);
1495 EXPECT_EQ(systemData->ParseDefaultMediaType(cap, capOpt), "stationery");
1496 }
1497
1498 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0089, TestSize.Level1)
1499 {
1500 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1501 EXPECT_NE(systemData, nullptr);
1502 PrinterCapability cap;
1503 Json::Value capOpt;
1504 capOpt["media-type-default"] = "stationery";
1505 EXPECT_EQ(systemData->ParseDefaultMediaType(cap, capOpt), "stationery");
1506 }
1507
1508 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0090, TestSize.Level1)
1509 {
1510 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1511 EXPECT_NE(systemData, nullptr);
1512 Json::Value jsonObject;
1513 Json::Value printerListJson;
1514 jsonObject["printer_list"] = printerListJson;
1515 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), false);
1516 }
1517
1518 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0091, TestSize.Level1)
1519 {
1520 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1521 EXPECT_NE(systemData, nullptr);
1522 Json::Value jsonObject;
1523 Json::Value printerListJson;
1524 std::string printerId = "testPrinterId";
1525 Json::Value printer;
1526 Json::Value printPreferenceJson;
1527 printer[printerId] = printPreferenceJson;
1528 printerListJson.append(printer);
1529 jsonObject["printer_list"] = printerListJson;
1530 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1531 }
1532
1533 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0092, TestSize.Level1)
1534 {
1535 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1536 EXPECT_NE(systemData, nullptr);
1537 Json::Value jsonObject;
1538 Json::Value printerListJson;
1539 std::string printerId = "testPrinterId";
1540 Json::Value printer;
1541 Json::Value printPreferenceJson;
1542 Json::Value setting;
1543 printPreferenceJson["setting"] = setting;
1544 printer[printerId] = printPreferenceJson;
1545 printerListJson.append(printer);
1546 jsonObject["printer_list"] = printerListJson;
1547 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1548 }
1549
1550 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0093, TestSize.Level1)
1551 {
1552 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1553 EXPECT_NE(systemData, nullptr);
1554 Json::Value jsonObject;
1555 Json::Value printerListJson;
1556 std::string printerId = "testPrinterId";
1557 Json::Value printer;
1558 Json::Value printPreferenceJson;
1559 Json::Value setting;
1560 printPreferenceJson["setting"] = setting;
1561 printer[printerId] = printPreferenceJson;
1562 printerListJson.append(printer);
1563 jsonObject["printer_list"] = printerListJson;
1564 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1565 }
1566
1567 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0094, TestSize.Level1)
1568 {
1569 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1570 EXPECT_NE(systemData, nullptr);
1571 Json::Value jsonObject;
1572 Json::Value printerListJson;
1573 std::string printerId = "testPrinterId";
1574 Json::Value printer;
1575 Json::Value printPreferenceJson;
1576 Json::Value setting;
1577 setting["pagesizeId"] = "ISO_A4";
1578 printPreferenceJson["setting"] = setting;
1579 printer[printerId] = printPreferenceJson;
1580 printerListJson.append(printer);
1581 jsonObject["printer_list"] = printerListJson;
1582 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1583 }
1584
1585 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0095, TestSize.Level1)
1586 {
1587 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1588 EXPECT_NE(systemData, nullptr);
1589 std::string printerId = "testPrinterId";
1590 std::shared_ptr<PrinterInfo> printerInfo = std::make_shared<PrinterInfo>();
1591 printerInfo->SetPrinterId(printerId);
1592 systemData->connectingIpPrinterInfoList_[printerId] = printerInfo;
1593 EXPECT_EQ(systemData->QueryIpPrinterInfoById(printerId)->GetPrinterId(), printerId);
1594 }
1595
1596 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0096, TestSize.Level1)
1597 {
1598 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1599 EXPECT_NE(systemData, nullptr);
1600 systemData->AddIpPrinterToList(nullptr);
1601 EXPECT_EQ(systemData->connectingIpPrinterInfoList_.size(), 0);
1602 }
1603
1604 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0097, TestSize.Level1)
1605 {
1606 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1607 EXPECT_NE(systemData, nullptr);
1608 std::shared_ptr<PrinterInfo> printerInfo = std::make_shared<PrinterInfo>();
1609 systemData->AddIpPrinterToList(printerInfo);
1610 EXPECT_EQ(systemData->connectingIpPrinterInfoList_.size(), 1);
1611 }
1612
1613 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0098, TestSize.Level1)
1614 {
1615 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1616 EXPECT_NE(systemData, nullptr);
1617 std::vector<int32_t> allPrintUserList;
1618 Json::Value jsonObject;
1619 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), false);
1620 }
1621
1622 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0099, TestSize.Level1)
1623 {
1624 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1625 EXPECT_NE(systemData, nullptr);
1626 std::vector<int32_t> allPrintUserList;
1627 Json::Value jsonObject;
1628 Json::Value userDataJson;
1629 jsonObject["print_user_data"] = userDataJson;
1630 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), false);
1631 }
1632
1633 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0100, TestSize.Level1)
1634 {
1635 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1636 EXPECT_NE(systemData, nullptr);
1637 std::vector<int32_t> allPrintUserList;
1638 Json::Value jsonObject;
1639 Json::Value userDataJson;
1640 jsonObject["print_user_data"] = userDataJson;
1641 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), false);
1642 }
1643
1644 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0101, TestSize.Level1)
1645 {
1646 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1647 EXPECT_NE(systemData, nullptr);
1648 std::vector<int32_t> allPrintUserList;
1649 Json::Value jsonObject;
1650 Json::Value userDataJson;
1651 userDataJson[""] = "user1";
1652 userDataJson["100"] = "user2";
1653 jsonObject["print_user_data"] = userDataJson;
1654 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), true);
1655 }
1656
1657 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0102, TestSize.Level1)
1658 {
1659 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1660 EXPECT_NE(systemData, nullptr);
1661 std::string printerId = "123";
1662 PrinterCapability printerCapability;
1663 std::vector<PrintPageSize> pageSizeList;
1664 PrintPageSize pageSize;
1665 pageSizeList.push_back(pageSize);
1666 printerCapability.SetSupportedPageSize(pageSizeList);
1667 Json::Value opsJson;
1668 opsJson["printerName"] = "123";
1669 printerCapability.SetOption(PrintJsonUtil::WriteString(opsJson));
1670 Json::Value jsonObject;
1671 Json::Value printerMapJson;
1672 Json::Value item;
1673 item["id"] = "123";
1674 item["name"] = "123";
1675 item["uri"] = "123";
1676 item["maker"] = "123";
1677 printerMapJson.append(item);
1678 jsonObject["printer_list"] = printerMapJson;
1679 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1680 }
1681
1682 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0103, TestSize.Level1)
1683 {
1684 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1685 EXPECT_NE(systemData, nullptr);
1686 std::string printerId = "123";
1687 PrinterCapability printerCapability;
1688 std::vector<PrintPageSize> pageSizeList;
1689 PrintPageSize pageSize;
1690 pageSizeList.push_back(pageSize);
1691 printerCapability.SetSupportedPageSize(pageSizeList);
1692 Json::Value opsJson;
1693 opsJson["printerName"] = "123";
1694 printerCapability.SetOption(PrintJsonUtil::WriteString(opsJson));
1695 Json::Value jsonObject;
1696 Json::Value printerMapJson;
1697 Json::Value item;
1698 item["id"] = "123";
1699 item["name"] = "123";
1700 item["uri"] = "123";
1701 item["maker"] = "123";
1702 Json::Value capsJson;
1703 item["capability"] = capsJson;
1704 printerMapJson.append(item);
1705 jsonObject["printer_list"] = printerMapJson;
1706 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1707 }
1708
1709 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0104, TestSize.Level1)
1710 {
1711 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1712 EXPECT_NE(systemData, nullptr);
1713 std::shared_ptr<PrinterInfo> printerInfo = std::make_shared<PrinterInfo>();
1714 std::string printerId = "1234";
1715 std::string uri = "testUri";
1716 printerInfo->SetPrinterId(printerId);
1717 printerInfo->SetUri(uri);
1718 systemData->UpdatePrinterUri(printerInfo);
1719
1720 CupsPrinterInfo cupsPrinterInfo;
1721 systemData->addedPrinterMap_.Insert(printerId, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
1722 systemData->UpdatePrinterUri(printerInfo);
1723 CupsPrinterInfo cupsPrinter;
1724 systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinter);
1725 EXPECT_EQ(cupsPrinter.uri, uri);
1726 }
1727 } // namespace Print
1728 } // namespace OHOS
1729