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 <nlohmann/json.hpp>
21 #include "printer_info.h"
22 #define private public
23 #include "print_system_data.h"
24 #undef private
25 #include "print_log.h"
26 #include "print_constant.h"
27 
28 using namespace testing::ext;
29 using json = nlohmann::json;
30 
31 namespace OHOS {
32 namespace Print {
33 
34 class PrintSystemDataTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40 };
41 
SetUpTestCase(void)42 void PrintSystemDataTest::SetUpTestCase(void) {}
43 
TearDownTestCase(void)44 void PrintSystemDataTest::TearDownTestCase(void) {}
45 
SetUp(void)46 void PrintSystemDataTest::SetUp(void)
47 {
48     static int32_t testNo = 0;
49     PRINT_HILOGI("PrintSystemDataTest_%{public}d", ++testNo);
50 }
51 
TearDown(void)52 void PrintSystemDataTest::TearDown(void) {}
53 
54 /**
55  * @tc.name: PrintSystemDataTest_0001
56  * @tc.desc: Verify the PrintSystemData function.
57  * @tc.type: FUNC
58  * @tc.require:
59  */
60 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0001, TestSize.Level1)
61 {
62     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
63     const std::string PRINTER_LIST_FILE = "/data/service/el2/public/print_service/printer_list.json";
64     std::ifstream f(PRINTER_LIST_FILE.c_str());
65     EXPECT_EQ(systemData->Init(), f.good());
66 }
67 
68 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0002, TestSize.Level1)
69 {
70     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
71     EXPECT_NE(systemData, nullptr);
72     std::string printerId = "1234";
73     CupsPrinterInfo cupsPrinterInfo;
74     systemData->InsertCupsPrinter(printerId, cupsPrinterInfo, false);
75     cupsPrinterInfo.name = "HUAWEI_PixLab_V1-0105";
76     cupsPrinterInfo.uri = "ipp://192.168.186.1:631/ipp/print";
77     cupsPrinterInfo.maker = "HUAWEI PixLab V1";
78     systemData->InsertCupsPrinter(printerId, cupsPrinterInfo, false);
79     std::map<std::string, std::shared_ptr<CupsPrinterInfo>> addedPrinterMap;
80     addedPrinterMap[printerId] = std::make_shared<CupsPrinterInfo>(cupsPrinterInfo);
81     EXPECT_EQ(addedPrinterMap.size(), 1);
82 }
83 
84 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0003, TestSize.Level1)
85 {
86     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
87     EXPECT_NE(systemData, nullptr);
88     EXPECT_EQ(systemData->SaveCupsPrinterMap(), true);
89 }
90 
91 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0004, TestSize.Level1)
92 {
93     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
94     EXPECT_NE(systemData, nullptr);
95     std::string printerName = "Direct Pixlab1620";
96     EXPECT_EQ(systemData->QueryPrinterIdByStandardizeName(printerName), "");
97     systemData->addedPrinterMap_.Insert("1234", nullptr);
98     systemData->QueryPrinterIdByStandardizeName(printerName);
99     EXPECT_EQ(systemData->SaveCupsPrinterMap(), true);
100 }
101 
102 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0005, TestSize.Level1)
103 {
104     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
105     EXPECT_NE(systemData, nullptr);
106     std::string printerName = "Direct Pixlab1620";
107     EXPECT_EQ(systemData->QueryPrinterIdByStandardizeName(printerName), "");
108     std::string re = systemData->QueryPrinterIdByStandardizeName(printerName);
109     std::string printerId = "1234";
110     CupsPrinterInfo cupsPrinterInfo;
111     cupsPrinterInfo.name = "Direct Pixlab1620";
112     std::map<std::string, std::shared_ptr<CupsPrinterInfo>> addedPrinterMap;
113     addedPrinterMap[printerId] = std::make_shared<CupsPrinterInfo>(cupsPrinterInfo);
114     EXPECT_EQ(addedPrinterMap.size(), 1);
115     if (cupsPrinterInfo.name == printerName) {
116         re = printerId;
117     }
118 }
119 
120 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0006, TestSize.Level1)
121 {
122     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
123     EXPECT_NE(systemData, nullptr);
124     std::string printerId = "1234";
125     CupsPrinterInfo cupsPrinterInfo1;
126     cupsPrinterInfo1.name = "Direct Pixlab1620";
127     CupsPrinterInfo cupsPrinterInfo2;
128     EXPECT_EQ(systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2), false);
129     std::map<std::string, std::shared_ptr<CupsPrinterInfo>> addedPrinterMap;
130     addedPrinterMap[printerId] = std::make_shared<CupsPrinterInfo>(cupsPrinterInfo1);
131     EXPECT_EQ(addedPrinterMap.size(), 1);
132     if (addedPrinterMap.count(printerId)) {
133         cupsPrinterInfo2 = cupsPrinterInfo1;
134         EXPECT_EQ(cupsPrinterInfo2.name, cupsPrinterInfo1.name);
135     }
136 }
137 
138 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0007, TestSize.Level1)
139 {
140     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
141     EXPECT_NE(systemData, nullptr);
142     std::string printerId = "1234";
143     PrinterInfo printerInfo;
144     systemData->InsertPrinterInfo(printerId, printerInfo);
145     std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterInfoList;
146     addedPrinterInfoList[printerId] = std::make_shared<PrinterInfo>(printerInfo);
147     EXPECT_EQ(addedPrinterInfoList.size(), 1);
148 }
149 
150 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0008, TestSize.Level1)
151 {
152     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
153     EXPECT_NE(systemData, nullptr);
154     std::string printerId = "1234";
155     EXPECT_EQ(systemData->QueryPrinterInfoByPrinterId(printerId), nullptr);
156     std::shared_ptr<PrinterInfo> result = std::make_shared<PrinterInfo>();
157     systemData->QueryPrinterInfoByPrinterId(printerId);
158     PrinterInfo printerInfo;
159     printerInfo.SetPrinterName("123");
160     std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterInfoList;
161     addedPrinterInfoList[printerId] = std::make_shared<PrinterInfo>(printerInfo);
162     EXPECT_EQ(addedPrinterInfoList.size(), 1);
163     if (addedPrinterInfoList.count(printerId)) {
164         result = addedPrinterInfoList[printerId];
165         EXPECT_EQ(result->GetPrinterName(), "123");
166     }
167 }
168 
169 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0009, TestSize.Level1)
170 {
171     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
172     EXPECT_NE(systemData, nullptr);
173     nlohmann::json printerMapJson = nlohmann::json::array();
174     nlohmann::json printerJson;
175     printerJson["id"] = "com.ohos.spooler:mdns://9e9561ad-0e30-1000-8000-9c9561ad0e30";
176     printerJson["maker"] = "HUAWEI PixLab V1";
177     printerJson["name"] = "HUAWEI_PixLab_V1-0105";
178     printerJson["uri"] = "ipp://192.168.186.1:631/ipp/print";
179     printerMapJson.push_back(printerJson);
180     nlohmann::json jsonObject;
181     jsonObject["version"] = "v1";
182     jsonObject["printer_list"] = printerMapJson;
183     EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
184     EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
185     std::string printerName = systemData->QueryPrinterIdByStandardizeName("HUAWEI_PixLab_V1-0105");
186     EXPECT_EQ(systemData->SaveCupsPrinterMap(), true);
187 }
188 
189 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0010, TestSize.Level1)
190 {
191     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
192     EXPECT_NE(systemData, nullptr);
193     nlohmann::json printerMapJson;
194     printerMapJson["printer"] = "1234";
195     EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
196     printerMapJson["printer_list"] = "1234";
197     EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
198 }
199 
200 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0011, TestSize.Level1)
201 {
202     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
203     EXPECT_NE(systemData, nullptr);
204     systemData->addedPrinterMap_.Insert("1", nullptr);
205     systemData->SaveCupsPrinterMap();
206     CupsPrinterInfo cupsPrinterInfo;
207     cupsPrinterInfo.name = "print";
208     cupsPrinterInfo.uri = "123";
209     cupsPrinterInfo.maker = "print";
210     systemData->addedPrinterMap_.Insert("2", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
211     systemData->SaveCupsPrinterMap();
212 }
213 
214 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0012, TestSize.Level1)
215 {
216     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
217     EXPECT_NE(systemData, nullptr);
218     systemData->addedPrinterMap_.Insert("1", nullptr);
219     std::string printerName = "Direct";
220     systemData->QueryPrinterIdByStandardizeName(printerName);
221     systemData->SaveCupsPrinterMap();
222     CupsPrinterInfo cupsPrinterInfo;
223     cupsPrinterInfo.name = "Direct";
224     cupsPrinterInfo.uri = "123";
225     cupsPrinterInfo.maker = "print";
226     systemData->addedPrinterMap_.Insert("2", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
227     systemData->QueryPrinterIdByStandardizeName(printerName);
228     cupsPrinterInfo.name = "223";
229     systemData->addedPrinterMap_.Insert("4", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
230     systemData->QueryPrinterIdByStandardizeName(printerName);
231 }
232 
233 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0013, TestSize.Level1)
234 {
235     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
236     EXPECT_NE(systemData, nullptr);
237     std::string printerId = "1234";
238     CupsPrinterInfo cupsPrinterInfo2;
239     systemData->addedPrinterMap_.Insert("1", nullptr);
240     systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2);
241     systemData->SaveCupsPrinterMap();
242     CupsPrinterInfo cupsPrinterInfo;
243     cupsPrinterInfo.name = "Direct Pixlab1620";
244     cupsPrinterInfo.uri = "123";
245     cupsPrinterInfo.maker = "print";
246     systemData->addedPrinterMap_.Insert("123", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
247     CupsPrinterInfo cupsPrinterInfo3;
248     systemData->addedPrinterMap_.Insert("11", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo3));
249     systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2);
250     systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
251     systemData->QueryCupsPrinterInfoByPrinterId(printerId, cupsPrinterInfo2);
252 }
253 
254 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0014, TestSize.Level1)
255 {
256     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
257     EXPECT_NE(systemData, nullptr);
258     std::string printerId = "1234";
259     PrinterInfo printerInfo;
260     systemData->InsertPrinterInfo(printerId, printerInfo);
261     systemData->addedPrinterMap_.Insert("1", nullptr);
262     systemData->InsertPrinterInfo(printerId, printerInfo);
263 }
264 
265 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0015, TestSize.Level1)
266 {
267     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
268     EXPECT_NE(systemData, nullptr);
269     std::string printerId = "1234";
270     PrinterInfo printerInfo;
271     systemData->addedPrinterInfoList_["1"] = nullptr;
272     systemData->QueryPrinterInfoByPrinterId(printerId);
273     systemData->addedPrinterInfoList_["1234"] = std::make_shared<PrinterInfo>(printerInfo);
274     systemData->QueryPrinterInfoByPrinterId(printerId);
275 }
276 
277 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0016, TestSize.Level1)
278 {
279     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
280     EXPECT_NE(systemData, nullptr);
281     std::string printerId = "1234";
282     CupsPrinterInfo cupsPrinterInfo;
283     systemData->InsertCupsPrinter(printerId, cupsPrinterInfo, false);
284     systemData->addedPrinterMap_.Insert("1234", nullptr);
285     systemData->InsertCupsPrinter(printerId, cupsPrinterInfo, false);
286     systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
287     systemData->InsertCupsPrinter(printerId, cupsPrinterInfo, false);
288 }
289 
290 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0017, TestSize.Level1)
291 {
292     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
293     EXPECT_NE(systemData, nullptr);
294     nlohmann::json printerMapJson = nlohmann::json::array();
295     nlohmann::json printerJson;
296     printerJson["id"] = 123;
297     printerJson["maker"] = 123;
298     printerJson["name"] = 132;
299     printerJson["uri"] = 123;
300     printerMapJson.push_back(printerJson);
301     nlohmann::json jsonObject;
302     jsonObject["version"] = "v1";
303     jsonObject["printer_list"] = printerMapJson;
304     systemData->ParsePrinterListJsonV1(jsonObject);
305 }
306 
307 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0018, TestSize.Level1)
308 {
309     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
310     EXPECT_NE(systemData, nullptr);
311     nlohmann::json printerMapJson = nlohmann::json::array();
312     nlohmann::json printerJson;
313     printerMapJson.push_back(printerJson);
314     nlohmann::json jsonObject;
315     jsonObject["version"] = "v1";
316     jsonObject["printer_list"] = printerMapJson;
317     systemData->ParsePrinterListJsonV1(jsonObject);
318 
319     nlohmann::json printerJson2;
320     printerJson2["id"] = "123";
321     printerMapJson.push_back(printerJson2);
322     nlohmann::json jsonObject2;
323     jsonObject2["version"] = "v1";
324     jsonObject2["printer_list"] = printerMapJson;
325     systemData->ParsePrinterListJsonV1(jsonObject2);
326 
327     nlohmann::json printerJson3;
328     printerJson3["id"] = "123";
329     printerJson3["name"] = 132;
330     printerMapJson.push_back(printerJson3);
331     nlohmann::json jsonObject3;
332     jsonObject3["version"] = "v1";
333     jsonObject3["printer_list"] = printerMapJson;
334     systemData->ParsePrinterListJsonV1(jsonObject3);
335 
336     nlohmann::json printerJson4;
337     printerJson4["id"] = "123";
338     printerJson4["name"] = "132";
339     printerMapJson.push_back(printerJson4);
340     nlohmann::json jsonObject4;
341     jsonObject4["version"] = "v1";
342     jsonObject4["printer_list"] = printerMapJson;
343     systemData->ParsePrinterListJsonV1(jsonObject4);
344 
345     nlohmann::json printerJson5;
346     printerJson5["id"] = "123";
347     printerJson5["name"] = "132";
348     printerJson5["uri"] = 123;
349     printerMapJson.push_back(printerJson5);
350     nlohmann::json jsonObject5;
351     jsonObject5["version"] = "v1";
352     jsonObject5["printer_list"] = printerMapJson;
353     systemData->ParsePrinterListJsonV1(jsonObject5);
354 }
355 
356 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0019, TestSize.Level1)
357 {
358     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
359     EXPECT_NE(systemData, nullptr);
360     nlohmann::json printerMapJson = nlohmann::json::array();
361     nlohmann::json printerJson;
362     printerMapJson.push_back(printerJson);
363     nlohmann::json jsonObject;
364     jsonObject["version"] = "v1";
365     jsonObject["printer_list"] = printerMapJson;
366     systemData->ParsePrinterListJsonV1(jsonObject);
367 
368     nlohmann::json printerJson6;
369     printerJson6["id"] = "123";
370     printerJson6["name"] = "132";
371     printerJson6["uri"] = "123";
372     printerMapJson.push_back(printerJson6);
373     nlohmann::json jsonObject6;
374     jsonObject6["version"] = "v1";
375     jsonObject6["printer_list"] = printerMapJson;
376     systemData->ParsePrinterListJsonV1(jsonObject6);
377 
378     nlohmann::json printerJson7;
379     printerJson7["id"] = "123";
380     printerJson7["name"] = "132";
381     printerJson7["uri"] = "123";
382     printerJson7["maker"] = 123;
383     printerMapJson.push_back(printerJson7);
384     nlohmann::json jsonObject7;
385     jsonObject7["version"] = "v1";
386     jsonObject7["printer_list"] = printerMapJson;
387     systemData->ParsePrinterListJsonV1(jsonObject7);
388 }
389 
390 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0020, TestSize.Level1)
391 {
392     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
393     EXPECT_NE(systemData, nullptr);
394     nlohmann::json printerMapJson = nlohmann::json::array();
395     nlohmann::json printerJson;
396     printerJson["id"] = "123";
397     printerJson["name"] = "132";
398     printerJson["uri"] = "123";
399     printerJson["maker"] = 123;
400     nlohmann::json capsJson = nlohmann::json::array();
401     printerJson["capability"] = capsJson;
402     printerMapJson.push_back(printerJson);
403     nlohmann::json jsonObject;
404     jsonObject["version"] = "v1";
405     jsonObject["printer_list"] = printerMapJson;
406     systemData->ParsePrinterListJsonV1(jsonObject);
407 }
408 
409 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0021, TestSize.Level1)
410 {
411     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
412     EXPECT_NE(systemData, nullptr);
413     nlohmann::json printerMapJson = nlohmann::json::array();
414     nlohmann::json printerJson;
415     printerJson["id"] = "123";
416     printerJson["name"] = "132";
417     printerJson["uri"] = "123";
418     printerJson["maker"] = 123;
419     nlohmann::json capsJson = nlohmann::json::object();
420     printerJson["capability"] = capsJson;
421     printerMapJson.push_back(printerJson);
422     nlohmann::json jsonObject;
423     jsonObject["version"] = "v1";
424     jsonObject["printer_list"] = printerMapJson;
425     systemData->ParsePrinterListJsonV1(jsonObject);
426 }
427 
428 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0022, TestSize.Level1)
429 {
430     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
431     EXPECT_NE(systemData, nullptr);
432     std::string printerId = "1234";
433     CupsPrinterInfo cupsPrinterInfo;
434     systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
435     systemData->InsertCupsPrinter(printerId, cupsPrinterInfo, true);
436 }
437 
438 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0023, TestSize.Level1)
439 {
440     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
441     EXPECT_NE(systemData, nullptr);
442     std::string printerId = "1234";
443     CupsPrinterInfo cupsPrinterInfo;
444     systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
445     systemData->DeleteCupsPrinter(printerId);
446 }
447 
448 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0024, TestSize.Level1)
449 {
450     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
451     EXPECT_NE(systemData, nullptr);
452     std::string printerId = "1234";
453     systemData->addedPrinterMap_.Insert("1", nullptr);
454     CupsPrinterInfo cupsPrinterInfo;
455     cupsPrinterInfo.name = "Direct";
456     cupsPrinterInfo.uri = "123";
457     cupsPrinterInfo.maker = "print";
458     systemData->addedPrinterMap_.Insert("2", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
459     CupsPrinterInfo cupsPrinterInfo2;
460     cupsPrinterInfo2.name = "Direct";
461     cupsPrinterInfo2.uri = "123";
462     cupsPrinterInfo2.maker = "print";
463     systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo2));
464     systemData->UpdatePrinterStatus(printerId, PRINTER_STATUS_IDLE);
465 }
466 
467 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0025, TestSize.Level1)
468 {
469     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
470     EXPECT_NE(systemData, nullptr);
471     std::string printerId = "1234";
472     systemData->addedPrinterMap_.Insert("1", nullptr);
473     CupsPrinterInfo cupsPrinterInfo;
474     cupsPrinterInfo.name = "Direct";
475     cupsPrinterInfo.uri = "123";
476     cupsPrinterInfo.maker = "print";
477     systemData->addedPrinterMap_.Insert("2", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
478     std::vector<std::string> printerNameList;
479     systemData->GetAddedPrinterListFromSystemData(printerNameList);
480 }
481 
482 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0026, TestSize.Level1)
483 {
484     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
485     EXPECT_NE(systemData, nullptr);
486     std::vector<std::string> printerNameList;
487     systemData->GetAddedPrinterListFromSystemData(printerNameList);
488     systemData->addedPrinterMap_.Insert("1", nullptr);
489     systemData->GetAddedPrinterListFromSystemData(printerNameList);
490     CupsPrinterInfo cupsPrinterInfo;
491     cupsPrinterInfo.name = "Direct";
492     cupsPrinterInfo.uri = "123";
493     cupsPrinterInfo.maker = "print";
494     systemData->addedPrinterMap_.Insert("1", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
495     systemData->GetAddedPrinterListFromSystemData(printerNameList);
496 }
497 
498 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0027, TestSize.Level1)
499 {
500     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
501     EXPECT_NE(systemData, nullptr);
502     PrinterCapability printerCapability;
503     nlohmann::json capsJson;
504     systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
505 }
506 
507 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0028, TestSize.Level1)
508 {
509     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
510     EXPECT_NE(systemData, nullptr);
511     PrinterCapability printerCapability;
512     PrintMargin minMargin;
513     printerCapability.SetMinMargin(minMargin);
514     std::vector<PrintResolution> resolutionList;
515     printerCapability.SetResolution(resolutionList);
516     std::string ops = "test";
517     printerCapability.SetOption(ops);
518     nlohmann::json capsJson;
519     systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
520 }
521 
522 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0029, TestSize.Level1)
523 {
524     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
525     EXPECT_NE(systemData, nullptr);
526     PrinterCapability printerCapability;
527     PrintMargin minMargin;
528     printerCapability.SetMinMargin(minMargin);
529     std::vector<PrintResolution> resolutionList;
530     printerCapability.SetResolution(resolutionList);
531     nlohmann::json ops;
532     ops["key"] = "value";
533     printerCapability.SetOption(ops.dump());
534     nlohmann::json capsJson;
535     systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
536 }
537 
538 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0030, TestSize.Level1)
539 {
540     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
541     EXPECT_NE(systemData, nullptr);
542     PrinterCapability printerCapability;
543     PrintMargin minMargin;
544     printerCapability.SetMinMargin(minMargin);
545     nlohmann::json capsJson;
546     systemData->ConvertPrintMarginToJson(printerCapability, capsJson);
547 }
548 
549 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0031, TestSize.Level1)
550 {
551     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
552     EXPECT_NE(systemData, nullptr);
553     PrinterCapability printerCapability;
554     PrintMargin minMargin;
555     minMargin.SetTop(100);
556     minMargin.SetBottom(100);
557     minMargin.SetLeft(100);
558     minMargin.SetRight(100);
559     printerCapability.SetMinMargin(minMargin);
560     nlohmann::json capsJson;
561     systemData->ConvertPrintMarginToJson(printerCapability, capsJson);
562 }
563 
564 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0032, TestSize.Level1)
565 {
566     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
567     EXPECT_NE(systemData, nullptr);
568     nlohmann::json capsJson;
569     PrinterCapability printerCapability;
570     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
571     capsJson["colorMode"] = "string";
572     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
573     capsJson["colorMode"] = 123;
574     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
575     capsJson["duplexMode"] = "string";
576     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
577     capsJson["duplexMode"] = 123;
578     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
579     nlohmann::json marginJson = nlohmann::json::array();
580     capsJson["minMargin"] = marginJson;
581     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
582     nlohmann::json marginJson2 = nlohmann::json::object();
583     capsJson["minMargin"] = marginJson2;
584     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
585     nlohmann::json pageSizeJson = nlohmann::json::object();
586     capsJson["pageSize"] = pageSizeJson;
587     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
588     nlohmann::json pageSizeJson2 = nlohmann::json::array();
589     nlohmann::json pageSize = nlohmann::json::array();
590     pageSizeJson2.push_back(pageSize);
591     capsJson["pageSize"] = pageSizeJson2;
592     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
593     nlohmann::json pageSizeJson3 = nlohmann::json::array();
594     capsJson["pageSize"] = pageSizeJson3;
595     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
596     nlohmann::json resolutionJson = nlohmann::json::object();
597     capsJson["resolution"] = resolutionJson;
598     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
599     nlohmann::json resolutionJson2 = nlohmann::json::array();
600     nlohmann::json resolution = nlohmann::json::array();
601     resolutionJson2.push_back(resolution);
602     capsJson["resolution"] = resolutionJson2;
603     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
604     nlohmann::json resolutionJson3 = nlohmann::json::array();
605     capsJson["resolution"] = resolutionJson3;
606     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
607     nlohmann::json opsJson = nlohmann::json::array();
608     capsJson["options"] = opsJson;
609     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
610     nlohmann::json opsJson2 = nlohmann::json::object();
611     capsJson["options"] = opsJson2;
612     systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
613 }
614 
615 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0033, TestSize.Level1)
616 {
617     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
618     EXPECT_NE(systemData, nullptr);
619     nlohmann::json capsJson;
620     PrinterCapability printerCapability;
621     nlohmann::json resolutionListJson = nlohmann::json::array();
622     nlohmann::json resolutionItem = nlohmann::json::array();
623     resolutionListJson.push_back(resolutionItem);
624     capsJson["resolution"] = resolutionListJson;
625     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
626     nlohmann::json resolutionListJson2 = nlohmann::json::array();
627     nlohmann::json resolutionItem2 = nlohmann::json::object();
628     resolutionListJson2.push_back(resolutionItem2);
629     capsJson["resolution"] = resolutionListJson2;
630     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
631     nlohmann::json resolutionListJson3 = nlohmann::json::array();
632     nlohmann::json resolutionItem3 = nlohmann::json::object();
633     resolutionItem3["id"] = 123;
634     resolutionListJson3.push_back(resolutionItem3);
635     capsJson["resolution"] = resolutionListJson3;
636     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
637     nlohmann::json resolutionListJson4 = nlohmann::json::array();
638     nlohmann::json resolutionItem4 = nlohmann::json::object();
639     resolutionItem4["id"] = "123";
640     resolutionListJson4.push_back(resolutionItem4);
641     capsJson["resolution"] = resolutionListJson4;
642     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
643 }
644 
645 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0034, TestSize.Level1)
646 {
647     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
648     EXPECT_NE(systemData, nullptr);
649     nlohmann::json capsJson;
650     PrinterCapability printerCapability;
651     nlohmann::json resolutionListJson = nlohmann::json::array();
652     nlohmann::json resolutionItem = nlohmann::json::object();
653     resolutionItem["id"] = "123";
654     resolutionItem["horizontalDpi"] = "123";
655     resolutionListJson.push_back(resolutionItem);
656     capsJson["resolution"] = resolutionListJson;
657     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
658     nlohmann::json resolutionListJson2 = nlohmann::json::array();
659     nlohmann::json resolutionItem2 = nlohmann::json::object();
660     resolutionItem2["id"] = "123";
661     resolutionItem2["horizontalDpi"] = 123;
662     resolutionListJson2.push_back(resolutionItem2);
663     capsJson["resolution"] = resolutionListJson2;
664     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
665     nlohmann::json resolutionListJson3 = nlohmann::json::array();
666     nlohmann::json resolutionItem3 = nlohmann::json::object();
667     resolutionItem3["id"] = "123";
668     resolutionItem3["horizontalDpi"] = 123;
669     resolutionItem3["verticalDpi"] = "123";
670     resolutionListJson3.push_back(resolutionItem3);
671     capsJson["resolution"] = resolutionListJson3;
672     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
673     nlohmann::json resolutionListJson4 = nlohmann::json::array();
674     nlohmann::json resolutionItem4 = nlohmann::json::object();
675     resolutionItem4["id"] = "123";
676     resolutionItem4["horizontalDpi"] = 123;
677     resolutionItem4["verticalDpi"] = 123;
678     resolutionListJson4.push_back(resolutionItem4);
679     capsJson["resolution"] = resolutionListJson4;
680     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
681 }
682 
683 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0035, TestSize.Level1)
684 {
685     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
686     EXPECT_NE(systemData, nullptr);
687     nlohmann::json capsJson;
688     PrinterCapability printerCapability;
689     nlohmann::json resolutionListJson = nlohmann::json::array();
690     capsJson["resolution"] = resolutionListJson;
691     systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
692 }
693 
694 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0036, TestSize.Level1)
695 {
696     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
697     EXPECT_NE(systemData, nullptr);
698     nlohmann::json capsJson;
699     PrinterCapability printerCapability;
700     nlohmann::json pageSizeListJson = nlohmann::json::array();
701     capsJson["pageSize"] = pageSizeListJson;
702     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
703 
704     nlohmann::json pageSizeListJson2 = nlohmann::json::array();
705     nlohmann::json pageSizeItem2 = nlohmann::json::array();
706     pageSizeListJson2.push_back(pageSizeItem2);
707     capsJson["pageSize"] = pageSizeListJson2;
708     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
709 
710     nlohmann::json pageSizeListJson3 = nlohmann::json::array();
711     nlohmann::json pageSizeItem3 = nlohmann::json::object();
712     pageSizeItem3["id"] = 123;
713     pageSizeListJson3.push_back(pageSizeItem3);
714     capsJson["pageSize"] = pageSizeListJson3;
715     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
716 
717     nlohmann::json pageSizeListJson4 = nlohmann::json::array();
718     nlohmann::json pageSizeItem4 = nlohmann::json::object();
719     pageSizeItem4["id"] = "123";
720     pageSizeListJson4.push_back(pageSizeItem4);
721     capsJson["pageSize"] = pageSizeListJson4;
722     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
723 }
724 
725 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0037, TestSize.Level1)
726 {
727     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
728     EXPECT_NE(systemData, nullptr);
729     nlohmann::json capsJson;
730     PrinterCapability printerCapability;
731     nlohmann::json pageSizeListJson = nlohmann::json::array();
732     nlohmann::json pageSizeItem = nlohmann::json::object();
733     pageSizeItem["id"] = "123";
734     pageSizeItem["name"] = 123;
735     pageSizeListJson.push_back(pageSizeItem);
736     capsJson["pageSize"] = pageSizeListJson;
737     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
738 
739     nlohmann::json pageSizeListJson2 = nlohmann::json::array();
740     nlohmann::json pageSizeItem2 = nlohmann::json::object();
741     pageSizeItem2["id"] = "123";
742     pageSizeItem2["name"] = "123";
743     pageSizeListJson2.push_back(pageSizeItem2);
744     capsJson["pageSize"] = pageSizeListJson2;
745     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
746 
747     nlohmann::json pageSizeListJson3 = nlohmann::json::array();
748     nlohmann::json pageSizeItem3 = nlohmann::json::object();
749     pageSizeItem3["id"] = "123";
750     pageSizeItem3["name"] = "123";
751     pageSizeItem3["width"] = "123";
752     pageSizeListJson3.push_back(pageSizeItem3);
753     capsJson["pageSize"] = pageSizeListJson3;
754     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
755 
756     nlohmann::json pageSizeListJson4 = nlohmann::json::array();
757     nlohmann::json pageSizeItem4 = nlohmann::json::object();
758     pageSizeItem4["id"] = "123";
759     pageSizeItem4["name"] = "123";
760     pageSizeItem4["width"] = 123;
761     pageSizeListJson4.push_back(pageSizeItem4);
762     capsJson["pageSize"] = pageSizeListJson4;
763     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
764 }
765 
766 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0038, TestSize.Level1)
767 {
768     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
769     EXPECT_NE(systemData, nullptr);
770     nlohmann::json capsJson;
771     PrinterCapability printerCapability;
772     nlohmann::json pageSizeListJson = nlohmann::json::array();
773     nlohmann::json pageSizeItem = nlohmann::json::object();
774     pageSizeItem["id"] = "123";
775     pageSizeItem["name"] = "123";
776     pageSizeItem["width"] = 123;
777     pageSizeItem["height"] = "123";
778     pageSizeListJson.push_back(pageSizeItem);
779     capsJson["pageSize"] = pageSizeListJson;
780     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
781 
782     nlohmann::json pageSizeListJson2 = nlohmann::json::array();
783     nlohmann::json pageSizeItem2 = nlohmann::json::object();
784     pageSizeItem2["id"] = "123";
785     pageSizeItem2["name"] = "123";
786     pageSizeItem2["width"] = 123;
787     pageSizeItem2["height"] = 123;
788     pageSizeListJson2.push_back(pageSizeItem2);
789     capsJson["pageSize"] = pageSizeListJson2;
790     systemData->ConvertJsonToPageSize(capsJson, printerCapability);
791 }
792 
793 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0039, TestSize.Level1)
794 {
795     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
796     EXPECT_NE(systemData, nullptr);
797     nlohmann::json capsJson;
798     PrinterCapability printerCapability;
799     nlohmann::json marginJson = nlohmann::json::object();
800     capsJson["minMargin"] = marginJson;
801     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
802 
803     nlohmann::json marginJson2 = nlohmann::json::object();
804     marginJson2["top"] = "123";
805     capsJson["minMargin"] = marginJson2;
806     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
807 
808     nlohmann::json marginJson3 = nlohmann::json::object();
809     marginJson3["top"] = 123;
810     capsJson["minMargin"] = marginJson3;
811     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
812 
813     nlohmann::json marginJson4 = nlohmann::json::object();
814     marginJson4["top"] = 123;
815     marginJson4["bottom"] = "123";
816     capsJson["minMargin"] = marginJson4;
817     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
818 
819     nlohmann::json marginJson5 = nlohmann::json::object();
820     marginJson5["top"] = 123;
821     marginJson5["bottom"] = 123;
822     capsJson["minMargin"] = marginJson5;
823     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
824 
825     nlohmann::json marginJson6 = nlohmann::json::object();
826     marginJson6["top"] = 123;
827     marginJson6["bottom"] = 123;
828     marginJson6["left"] = "123";
829     capsJson["minMargin"] = marginJson6;
830     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
831 
832     nlohmann::json marginJson7 = nlohmann::json::object();
833     marginJson7["top"] = 123;
834     marginJson7["bottom"] = 123;
835     marginJson7["left"] = 123;
836     capsJson["minMargin"] = marginJson7;
837     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
838 }
839 
840 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0040, TestSize.Level1)
841 {
842     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
843     EXPECT_NE(systemData, nullptr);
844     nlohmann::json capsJson;
845     PrinterCapability printerCapability;
846     nlohmann::json marginJson = nlohmann::json::object();
847     marginJson["top"] = 123;
848     marginJson["bottom"] = 123;
849     marginJson["left"] = 123;
850     marginJson["right"] = "123";
851     capsJson["minMargin"] = marginJson;
852     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
853 
854     nlohmann::json marginJson2 = nlohmann::json::object();
855     marginJson2["top"] = 123;
856     marginJson2["bottom"] = 123;
857     marginJson2["left"] = 123;
858     marginJson2["right"] = 123;
859     capsJson["minMargin"] = marginJson2;
860     systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
861 }
862 
863 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0041, TestSize.Level1)
864 {
865     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
866     EXPECT_NE(systemData, nullptr);
867     CupsPrinterInfo cupsPrinter;
868     std::string printerId = "123";
869     PrinterCapability printerCapability;
870     systemData->GetPrinterCapabilityFromSystemData(cupsPrinter, printerId, printerCapability);
871 }
872 
873 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0042, TestSize.Level1)
874 {
875     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
876     EXPECT_NE(systemData, nullptr);
877     CupsPrinterInfo cupsPrinter;
878     std::string printerId = "123";
879     PrinterCapability printerCapability;
880     PrinterCapability printerCapability2;
881     nlohmann::json opsJson;
882     opsJson["key"] = "value";
883     printerCapability2.SetOption(opsJson.dump());
884     std::vector<PrintPageSize> pageSizeList;
885     PrintPageSize pageSize;
886     pageSizeList.push_back(pageSize);
887     printerCapability2.SetSupportedPageSize(pageSizeList);
888     cupsPrinter.printerCapability = printerCapability2;
889     systemData->GetPrinterCapabilityFromSystemData(cupsPrinter, printerId, printerCapability);
890 }
891 
892 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0043, TestSize.Level1)
893 {
894     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
895     EXPECT_NE(systemData, nullptr);
896     nlohmann::json object;
897     std::string printerId = "123";
898     systemData->CheckPrinterInfoJson(object, printerId);
899 }
900 
901 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0044, TestSize.Level1)
902 {
903     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
904     EXPECT_NE(systemData, nullptr);
905     nlohmann::json object;
906     object["id"] = 123;
907     std::string printerId = "123";
908     systemData->CheckPrinterInfoJson(object, printerId);
909 
910     nlohmann::json object2;
911     object2["id"] = "12";
912     systemData->CheckPrinterInfoJson(object2, printerId);
913 
914     nlohmann::json object3;
915     object3["id"] = "123";
916     systemData->CheckPrinterInfoJson(object3, printerId);
917 
918     nlohmann::json object4;
919     object4["id"] = "123";
920     object4["name"] = 123;
921     systemData->CheckPrinterInfoJson(object4, printerId);
922 
923     nlohmann::json object5;
924     object5["id"] = "123";
925     object5["name"] = "123";
926     systemData->CheckPrinterInfoJson(object5, printerId);
927 
928     nlohmann::json object6;
929     object6["id"] = "123";
930     object6["name"] = "123";
931     object6["uri"] = 123;
932     systemData->CheckPrinterInfoJson(object6, printerId);
933 
934     nlohmann::json object7;
935     object7["id"] = "123";
936     object7["name"] = "123";
937     object7["uri"] = "123";
938     systemData->CheckPrinterInfoJson(object7, printerId);
939 }
940 
941 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0045, TestSize.Level1)
942 {
943     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
944     EXPECT_NE(systemData, nullptr);
945     nlohmann::json object;
946     object["id"] = "123";
947     object["name"] = "123";
948     object["uri"] = "123";
949     object["maker"] = 123;
950     std::string printerId = "123";
951     systemData->CheckPrinterInfoJson(object, printerId);
952 
953     nlohmann::json object2;
954     object2["id"] = "123";
955     object2["name"] = "123";
956     object2["uri"] = "123";
957     object2["maker"] = "123";
958     systemData->CheckPrinterInfoJson(object2, printerId);
959 
960     nlohmann::json object3;
961     object3["id"] = "123";
962     object3["name"] = "123";
963     object3["uri"] = "123";
964     object3["maker"] = "123";
965     object3["capability"] = "123";
966     systemData->CheckPrinterInfoJson(object3, printerId);
967 
968     nlohmann::json object4;
969     object4["id"] = "123";
970     object4["name"] = "123";
971     object4["uri"] = "123";
972     object4["maker"] = "123";
973     nlohmann::json capsJson = nlohmann::json::object();
974     object4["capability"] = capsJson;
975     systemData->CheckPrinterInfoJson(object4, printerId);
976 }
977 
978 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0046, TestSize.Level1)
979 {
980     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
981     EXPECT_NE(systemData, nullptr);
982     std::string printerId = "123";
983     systemData->IsPrinterAdded(printerId);
984     systemData->addedPrinterMap_.Insert("123", nullptr);
985     systemData->IsPrinterAdded(printerId);
986     CupsPrinterInfo cupsPrinterInfo;
987     cupsPrinterInfo.name = "Direct";
988     cupsPrinterInfo.uri = "123";
989     cupsPrinterInfo.maker = "print";
990     systemData->addedPrinterMap_.Insert("123", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
991     systemData->IsPrinterAdded(printerId);
992 }
993 
994 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0047, TestSize.Level1)
995 {
996     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
997     EXPECT_NE(systemData, nullptr);
998     std::string printerId = "1234";
999     PrinterInfo printerInfo;
1000     systemData->QueryPrinterInfoById(printerId, printerInfo);
1001     CupsPrinterInfo cupsPrinterInfo;
1002     cupsPrinterInfo.name = "Direct Pixlab1620";
1003     cupsPrinterInfo.uri = "123";
1004     cupsPrinterInfo.maker = "print";
1005     systemData->addedPrinterMap_.Insert("1234", std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
1006     systemData->QueryPrinterInfoById(printerId, printerInfo);
1007 }
1008 
1009 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0048, TestSize.Level1)
1010 {
1011     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1012     EXPECT_NE(systemData, nullptr);
1013     std::string printerId;
1014     nlohmann::json jsonObject;
1015     PrinterCapability printerCapability;
1016     systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1017 
1018     nlohmann::json printerMapJson = nlohmann::json::object();
1019     jsonObject["printer_list"] = printerMapJson;
1020     systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1021 
1022     nlohmann::json jsonObject2;
1023     nlohmann::json printerMapJson2 = nlohmann::json::array();
1024     jsonObject2["printer_list"] = printerMapJson2;
1025     systemData->GetPrinterCapabilityFromJson(printerId, jsonObject2, printerCapability);
1026 
1027     nlohmann::json jsonObject3;
1028     nlohmann::json printerMapJson3 = nlohmann::json::array();
1029     nlohmann::json item = nlohmann::json::object();
1030     item["key"] = "value";
1031     printerMapJson3.push_back(item);
1032     jsonObject3["printer_list"] = printerMapJson3;
1033     systemData->GetPrinterCapabilityFromJson(printerId, jsonObject3, printerCapability);
1034 }
1035 
1036 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0049, TestSize.Level1)
1037 {
1038     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1039     EXPECT_NE(systemData, nullptr);
1040     std::string printerId;
1041     PrinterCapability printerCapability;
1042     nlohmann::json jsonObject;
1043     nlohmann::json printerMapJson = nlohmann::json::array();
1044     nlohmann::json item = nlohmann::json::object();
1045     item["id"] = "123";
1046     item["name"] = "123";
1047     item["uri"] = "123";
1048     item["maker"] = "123";
1049     nlohmann::json capsJson = nlohmann::json::object();
1050     capsJson["key"] = "value";
1051     item["capability"] = capsJson;
1052     printerMapJson.push_back(item);
1053     jsonObject["printer_list"] = printerMapJson;
1054     systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1055 }
1056 
1057 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0050, TestSize.Level1)
1058 {
1059     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1060     EXPECT_NE(systemData, nullptr);
1061     std::string printerId;
1062     PrinterCapability printerCapability;
1063     nlohmann::json jsonObject;
1064     nlohmann::json printerMapJson = nlohmann::json::array();
1065     nlohmann::json item = nlohmann::json::object();
1066     item["id"] = "123";
1067     item["name"] = "123";
1068     item["uri"] = "123";
1069     item["maker"] = "123";
1070     nlohmann::json capsJson = nlohmann::json::object();
1071     systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
1072     item["capability"] = capsJson;
1073     printerMapJson.push_back(item);
1074     jsonObject["printer_list"] = printerMapJson;
1075     systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1076 }
1077 
1078 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0051, TestSize.Level1)
1079 {
1080     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1081     EXPECT_NE(systemData, nullptr);
1082     std::string printerId = "123";
1083     PrinterCapability printerCapability;
1084     std::vector<PrintPageSize> pageSizeList;
1085     PrintPageSize pageSize;
1086     pageSizeList.push_back(pageSize);
1087     printerCapability.SetSupportedPageSize(pageSizeList);
1088     nlohmann::json opsJson;
1089     opsJson["printerName"] = "123";
1090     printerCapability.SetOption(opsJson.dump());
1091     nlohmann::json jsonObject;
1092     nlohmann::json printerMapJson = nlohmann::json::array();
1093     nlohmann::json item = nlohmann::json::object();
1094     item["id"] = "123";
1095     item["name"] = "123";
1096     item["uri"] = "123";
1097     item["maker"] = "123";
1098     nlohmann::json capsJson = nlohmann::json::object();
1099     systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
1100     item["capability"] = capsJson;
1101     printerMapJson.push_back(item);
1102     jsonObject["printer_list"] = printerMapJson;
1103     systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1104 }
1105 
1106 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0052, TestSize.Level1)
1107 {
1108     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1109     EXPECT_NE(systemData, nullptr);
1110     std::string printerId = "";
1111     systemData->DeleteCupsPrinter(printerId);
1112 }
1113 
1114 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0053, TestSize.Level1)
1115 {
1116     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1117     EXPECT_NE(systemData, nullptr);
1118     std::string printerId = "1234";
1119     std::string printerAlias = "1234";
1120     systemData->UpdatePrinterAlias(printerId, printerAlias);
1121 
1122     CupsPrinterInfo cupsPrinterInfo;
1123     cupsPrinterInfo.alias = printerAlias;
1124     systemData->addedPrinterMap_.Insert(printerId, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo));
1125 
1126     bool ret = systemData->UpdatePrinterAlias(printerId, "");
1127     EXPECT_EQ(ret, true);
1128 
1129     systemData->UpdatePrinterAlias(printerId, printerAlias);
1130 }
1131 
1132 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0054, TestSize.Level1)
1133 {
1134     auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1135     EXPECT_NE(systemData, nullptr);
1136     std::string printerId1 = "1";
1137     CupsPrinterInfo cupsPrinterInfo1;
1138     systemData->addedPrinterMap_.Insert(printerId1, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo1));
1139     systemData->CheckPrinterBusy(printerId1);
1140 
1141     std::string printerId2 = "2";
1142     CupsPrinterInfo cupsPrinterInfo2;
1143     cupsPrinterInfo2.printerStatus = PRINTER_STATUS_BUSY;
1144     systemData->addedPrinterMap_.Insert(printerId2, std::make_shared<CupsPrinterInfo>(cupsPrinterInfo2));
1145     bool ret = systemData->CheckPrinterBusy(printerId2);
1146     EXPECT_EQ(ret, true);
1147 }
1148 
1149 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0055, TestSize.Level1)
1150 {
1151     auto systemData = std::make_shared<PrintSystemData>();
1152     EXPECT_NE(systemData, nullptr);
1153     std::string printerId1 = "1";
1154     std::string printerId2 = "2";
1155     std::string printerName = "name";
1156     auto printerInfo = std::make_shared<PrinterInfo>();
1157     EXPECT_NE(printerInfo, nullptr);
1158     printerInfo->SetPrinterId(printerId1);
1159     printerInfo->SetPrinterName(printerName);
1160     systemData->AddPrinterToDiscovery(printerInfo);
1161     EXPECT_EQ(systemData->GetDiscoveredPrinterCount(), 1);
1162     auto discoveredPrinter = systemData->QueryDiscoveredPrinterInfoById(printerId1);
1163     EXPECT_NE(discoveredPrinter, nullptr);
1164     discoveredPrinter = systemData->QueryDiscoveredPrinterInfoById(printerId2);
1165     EXPECT_EQ(discoveredPrinter, nullptr);
1166     discoveredPrinter = systemData->QueryDiscoveredPrinterInfoByName(printerName);
1167     EXPECT_NE(discoveredPrinter, nullptr);
1168     discoveredPrinter = systemData->QueryDiscoveredPrinterInfoByName(printerId2);
1169     EXPECT_EQ(discoveredPrinter, nullptr);
1170     systemData->RemovePrinterFromDiscovery(printerId1);
1171     EXPECT_EQ(systemData->GetDiscoveredPrinterCount(), 0);
1172     systemData->ClearDiscoveredPrinterList();
1173 }
1174 }  // namespace Print
1175 }  // namespace OHOS
1176