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_NeedRename, TestSize.Level1)
53 {
54 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
55 EXPECT_NE(systemData, nullptr);
56 std::string printerId = "1234";
57 PrinterInfo printerInfo;
58 systemData->InsertAddedPrinter(printerId, printerInfo);
59 printerInfo.SetPrinterName("HW_PixLab_V1-0105");
60 printerInfo.SetUri("ipp://192.168.186.1:631/ipp/print");
61 printerInfo.SetPrinterMake("HW PixLab V1");
62 systemData->InsertAddedPrinter(printerId, printerInfo);
63 std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterMap;
64 addedPrinterMap[printerId] = std::make_shared<PrinterInfo>(printerInfo);
65 EXPECT_EQ(addedPrinterMap.size(), 1);
66 }
67
68 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0004_NeedRename, 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_NeedRename, 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 PrinterInfo printerInfo;
85 printerInfo.SetPrinterName("Direct Pixlab1620");
86 std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterMap;
87 addedPrinterMap[printerId] = std::make_shared<PrinterInfo>(printerInfo);
88 EXPECT_EQ(addedPrinterMap.size(), 1);
89 if (printerInfo.GetPrinterName() == printerName) {
90 re = printerId;
91 }
92 }
93
94 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0006_NeedRename, TestSize.Level1)
95 {
96 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
97 EXPECT_NE(systemData, nullptr);
98 std::string printerId = "1234";
99 PrinterInfo printerInfo1;
100 printerInfo1.SetPrinterName("Direct Pixlab1620");
101 PrinterInfo printerInfo2;
102 EXPECT_EQ(systemData->QueryAddedPrinterInfoByPrinterId(printerId, printerInfo2), false);
103 std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterMap;
104 addedPrinterMap[printerId] = std::make_shared<PrinterInfo>(printerInfo1);
105 EXPECT_EQ(addedPrinterMap.size(), 1);
106 if (addedPrinterMap.count(printerId)) {
107 printerInfo2 = printerInfo1;
108 EXPECT_EQ(printerInfo2.GetPrinterName(), printerInfo1.GetPrinterName());
109 }
110 }
111
112 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0007_NeedRename, 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->InsertAddedPrinter(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_NeedRename, TestSize.Level1)
125 {
126 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
127 EXPECT_NE(systemData, nullptr);
128 std::string printerId = "1234";
129 std::shared_ptr<PrinterInfo> result = std::make_shared<PrinterInfo>();
130 PrinterInfo printerInfo;
131 printerInfo.SetPrinterName("123");
132 std::map<std::string, std::shared_ptr<PrinterInfo>> addedPrinterInfoList;
133 addedPrinterInfoList[printerId] = std::make_shared<PrinterInfo>(printerInfo);
134 EXPECT_EQ(addedPrinterInfoList.size(), 1);
135 if (addedPrinterInfoList.count(printerId)) {
136 result = addedPrinterInfoList[printerId];
137 EXPECT_EQ(result->GetPrinterName(), "123");
138 }
139 }
140
141 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0009_NeedRename, TestSize.Level1)
142 {
143 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
144 EXPECT_NE(systemData, nullptr);
145 Json::Value printerMapJson;
146 Json::Value printerJson;
147 printerJson["id"] = "com.ohos.spooler:mdns://9e9561ad-0e30-1000-8000-9c9561ad0e30";
148 printerJson["maker"] = "HUAWEI PixLab V1";
149 printerJson["name"] = "HUAWEI_PixLab_V1-0105";
150 printerJson["uri"] = "ipp://192.168.186.1:631/ipp/print";
151 printerMapJson.append(printerJson);
152 Json::Value jsonObject;
153 jsonObject["version"] = "v1";
154 jsonObject["printer_list"] = printerMapJson;
155 EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
156 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
157 }
158
159 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0010_NeedRename, TestSize.Level1)
160 {
161 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
162 EXPECT_NE(systemData, nullptr);
163 Json::Value printerMapJson;
164 printerMapJson["printer"] = "1234";
165 EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
166 printerMapJson["printer_list"] = "1234";
167 EXPECT_EQ(systemData->ParsePrinterListJsonV1(printerMapJson), false);
168 }
169
170 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0011_NeedRename, TestSize.Level1)
171 {
172 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
173 EXPECT_NE(systemData, nullptr);
174 systemData->addedPrinterMap_.Insert("1", nullptr);
175 systemData->SavePrinterFile("1");
176 }
177
178 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0012_NeedRename, TestSize.Level1)
179 {
180 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
181 EXPECT_NE(systemData, nullptr);
182 systemData->addedPrinterMap_.Insert("1", nullptr);
183 std::string printerName = "Direct";
184 systemData->QueryPrinterIdByStandardizeName(printerName);
185 systemData->SavePrinterFile("1");
186 PrinterInfo printerInfo;
187 printerInfo.SetPrinterName("Direct");
188 printerInfo.SetUri("123");
189 printerInfo.SetPrinterMake("print");
190 systemData->addedPrinterMap_.Insert("2", std::make_shared<PrinterInfo>(printerInfo));
191 EXPECT_EQ(systemData->QueryPrinterIdByStandardizeName(printerName), "2");
192 printerInfo.SetPrinterName("223");
193 systemData->addedPrinterMap_.Insert("4", std::make_shared<PrinterInfo>(printerInfo));
194 EXPECT_EQ(systemData->QueryPrinterIdByStandardizeName(printerName), "2");
195 }
196
197 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0013_NeedRename, TestSize.Level1)
198 {
199 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
200 EXPECT_NE(systemData, nullptr);
201 std::string printerId = "1234";
202 PrinterInfo printerInfo2;
203 systemData->addedPrinterMap_.Insert("1", nullptr);
204 systemData->QueryAddedPrinterInfoByPrinterId(printerId, printerInfo2);
205 systemData->SavePrinterFile("1");
206 PrinterInfo printerInfo;
207 printerInfo.SetPrinterName("Direct Pixlab1620");
208 printerInfo.SetUri("123");
209 printerInfo.SetPrinterMake("print");
210 systemData->addedPrinterMap_.Insert("123", std::make_shared<PrinterInfo>(printerInfo));
211 PrinterInfo printerInfo3;
212 systemData->addedPrinterMap_.Insert("11", std::make_shared<PrinterInfo>(printerInfo3));
213 EXPECT_EQ(systemData->QueryAddedPrinterInfoByPrinterId(printerId, printerInfo2), false);
214 systemData->addedPrinterMap_.Insert("1234", std::make_shared<PrinterInfo>(printerInfo));
215 EXPECT_EQ(systemData->QueryAddedPrinterInfoByPrinterId(printerId, printerInfo2), true);
216 }
217
218 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0014_NeedRename, TestSize.Level1)
219 {
220 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
221 EXPECT_NE(systemData, nullptr);
222 std::string printerId = "1234";
223 PrinterInfo printerInfo;
224 systemData->InsertAddedPrinter(printerId, printerInfo);
225 EXPECT_EQ(systemData->addedPrinterMap_.GetKeyList().size(), 1);
226 systemData->addedPrinterMap_.Insert("1", nullptr);
227 systemData->InsertAddedPrinter(printerId, printerInfo);
228 EXPECT_EQ(systemData->addedPrinterMap_.GetKeyList().size(), 1);
229 }
230
231 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0016_NeedRename, 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->InsertAddedPrinter(printerId, printerInfo);
238 systemData->addedPrinterMap_.Insert("1234", nullptr);
239 systemData->InsertAddedPrinter(printerId, printerInfo);
240 systemData->addedPrinterMap_.Insert("1234", std::make_shared<PrinterInfo>(printerInfo));
241 systemData->InsertAddedPrinter(printerId, printerInfo);
242 EXPECT_EQ(systemData->addedPrinterMap_.GetKeyList().size(), 1);
243 }
244
245 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0017_NeedRename, TestSize.Level1)
246 {
247 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
248 EXPECT_NE(systemData, nullptr);
249 Json::Value printerMapJson;
250 Json::Value printerJson;
251 printerJson["id"] = 123;
252 printerJson["maker"] = 123;
253 printerJson["name"] = 132;
254 printerJson["uri"] = 123;
255 printerMapJson.append(printerJson);
256 Json::Value jsonObject;
257 jsonObject["version"] = "v1";
258 jsonObject["printer_list"] = printerMapJson;
259 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
260 }
261
262 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0018_NeedRename, TestSize.Level1)
263 {
264 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
265 EXPECT_NE(systemData, nullptr);
266 Json::Value printerMapJson;
267 Json::Value printerJson;
268 printerMapJson.append(printerJson);
269 Json::Value jsonObject;
270 jsonObject["version"] = "v1";
271 jsonObject["printer_list"] = printerMapJson;
272 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
273
274 Json::Value printerJson2;
275 printerJson2["id"] = "123";
276 printerMapJson.append(printerJson2);
277 Json::Value jsonObject2;
278 jsonObject2["version"] = "v1";
279 jsonObject2["printer_list"] = printerMapJson;
280 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject2), true);
281
282 Json::Value printerJson3;
283 printerJson3["id"] = "123";
284 printerJson3["name"] = 132;
285 printerMapJson.append(printerJson3);
286 Json::Value jsonObject3;
287 jsonObject3["version"] = "v1";
288 jsonObject3["printer_list"] = printerMapJson;
289 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject3), true);
290
291 Json::Value printerJson4;
292 printerJson4["id"] = "123";
293 printerJson4["name"] = "132";
294 printerMapJson.append(printerJson4);
295 Json::Value jsonObject4;
296 jsonObject4["version"] = "v1";
297 jsonObject4["printer_list"] = printerMapJson;
298 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject4), true);
299
300 Json::Value printerJson5;
301 printerJson5["id"] = "123";
302 printerJson5["name"] = "132";
303 printerJson5["uri"] = 123;
304 printerMapJson.append(printerJson5);
305 Json::Value jsonObject5;
306 jsonObject5["version"] = "v1";
307 jsonObject5["printer_list"] = printerMapJson;
308 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject5), true);
309 }
310
311 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0019_NeedRename, TestSize.Level1)
312 {
313 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
314 EXPECT_NE(systemData, nullptr);
315 Json::Value printerMapJson;
316 Json::Value printerJson;
317 printerMapJson.append(printerJson);
318 Json::Value jsonObject;
319 jsonObject["version"] = "v1";
320 jsonObject["printer_list"] = printerMapJson;
321 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
322
323 Json::Value printerJson6;
324 printerJson6["id"] = "123";
325 printerJson6["name"] = "132";
326 printerJson6["uri"] = "123";
327 printerMapJson.append(printerJson6);
328 Json::Value jsonObject6;
329 jsonObject6["version"] = "v1";
330 jsonObject6["printer_list"] = printerMapJson;
331 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject6), true);
332
333 Json::Value printerJson7;
334 printerJson7["id"] = "123";
335 printerJson7["name"] = "132";
336 printerJson7["uri"] = "123";
337 printerJson7["maker"] = 123;
338 printerMapJson.append(printerJson7);
339 Json::Value jsonObject7;
340 jsonObject7["version"] = "v1";
341 jsonObject7["printer_list"] = printerMapJson;
342 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject7), true);
343 }
344
345 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0020_NeedRename, TestSize.Level1)
346 {
347 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
348 EXPECT_NE(systemData, nullptr);
349 Json::Value printerMapJson;
350 Json::Value printerJson;
351 printerJson["id"] = "123";
352 printerJson["name"] = "132";
353 printerJson["uri"] = "123";
354 printerJson["maker"] = "123";
355 Json::Value capsJson;
356 printerJson["capability"] = capsJson;
357 printerMapJson.append(printerJson);
358 Json::Value jsonObject;
359 jsonObject["version"] = "v1";
360 jsonObject["printer_list"] = printerMapJson;
361 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
362 }
363
364 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0021_NeedRename, TestSize.Level1)
365 {
366 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
367 EXPECT_NE(systemData, nullptr);
368 Json::Value printerMapJson;
369 Json::Value printerJson;
370 printerJson["id"] = "123";
371 printerJson["name"] = "132";
372 printerJson["uri"] = "123";
373 printerJson["maker"] = "123";
374 Json::Value capsJson;
375 printerJson["capability"] = capsJson;
376 printerMapJson.append(printerJson);
377 Json::Value jsonObject;
378 jsonObject["version"] = "v1";
379 jsonObject["printer_list"] = printerMapJson;
380 EXPECT_EQ(systemData->ParsePrinterListJsonV1(jsonObject), true);
381 }
382
383 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0022_NeedRename, TestSize.Level1)
384 {
385 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
386 EXPECT_NE(systemData, nullptr);
387 std::string printerId = "1234";
388 PrinterInfo printerInfo;
389 printerInfo.SetAlias("test");
390 systemData->addedPrinterMap_.Insert("1234", std::make_shared<PrinterInfo>(printerInfo));
391 systemData->InsertAddedPrinter(printerId, printerInfo);
392 EXPECT_EQ(systemData->addedPrinterMap_.GetKeyList().size(), 1);
393 }
394
395 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0023_NeedRename, TestSize.Level1)
396 {
397 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
398 EXPECT_NE(systemData, nullptr);
399 std::string printerId = "1234";
400 std::string printerName = "1234";
401 PrinterInfo printerInfo;
402 systemData->addedPrinterMap_.Insert("1234", std::make_shared<PrinterInfo>(printerInfo));
403 systemData->DeleteAddedPrinter(printerId, printerName);
404 EXPECT_EQ(systemData->addedPrinterMap_.GetKeyList().size(), 0);
405 }
406
407 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0024_NeedRename, TestSize.Level1)
408 {
409 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
410 EXPECT_NE(systemData, nullptr);
411 std::string printerId = "1234";
412 systemData->addedPrinterMap_.Insert("1", nullptr);
413 PrinterInfo printerInfo;
414 printerInfo.SetPrinterName("Direct");
415 printerInfo.SetUri("123");
416 printerInfo.SetPrinterMake("print");
417 systemData->addedPrinterMap_.Insert("2", std::make_shared<PrinterInfo>(printerInfo));
418 PrinterInfo printerInfo2;
419 printerInfo2.SetPrinterName("Direct");
420 printerInfo2.SetUri("123");
421 printerInfo2.SetPrinterMake("print");
422 systemData->addedPrinterMap_.Insert("1234", std::make_shared<PrinterInfo>(printerInfo2));
423 systemData->UpdatePrinterStatus(printerId, PRINTER_STATUS_IDLE);
424 PrinterInfo printerInfo3;
425 systemData->QueryAddedPrinterInfoByPrinterId(printerId, printerInfo3);
426 EXPECT_EQ(printerInfo3.GetPrinterStatus(), PRINTER_STATUS_IDLE);
427 }
428
429 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0025_NeedRename, TestSize.Level1)
430 {
431 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
432 EXPECT_NE(systemData, nullptr);
433 std::string printerId = "1234";
434 systemData->addedPrinterMap_.Insert("1", nullptr);
435 PrinterInfo printerInfo;
436 printerInfo.SetPrinterName("Direct");
437 printerInfo.SetUri("123");
438 printerInfo.SetPrinterMake("print");
439 systemData->addedPrinterMap_.Insert("2", std::make_shared<PrinterInfo>(printerInfo));
440 std::vector<std::string> printerNameList;
441 systemData->GetAddedPrinterListFromSystemData(printerNameList);
442 EXPECT_EQ(printerNameList.size(), 1);
443 }
444
445 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0026_NeedRename, TestSize.Level1)
446 {
447 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
448 EXPECT_NE(systemData, nullptr);
449 std::vector<std::string> printerNameList;
450 systemData->GetAddedPrinterListFromSystemData(printerNameList);
451 systemData->addedPrinterMap_.Insert("1", nullptr);
452 systemData->GetAddedPrinterListFromSystemData(printerNameList);
453 PrinterInfo printerInfo;
454 printerInfo.SetPrinterName("Direct");
455 printerInfo.SetUri("123");
456 printerInfo.SetPrinterMake("print");
457 systemData->addedPrinterMap_.Insert("1", std::make_shared<PrinterInfo>(printerInfo));
458 systemData->GetAddedPrinterListFromSystemData(printerNameList);
459 EXPECT_EQ(printerNameList.size(), 0);
460 }
461
462 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0027_NeedRename, TestSize.Level1)
463 {
464 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
465 EXPECT_NE(systemData, nullptr);
466 PrinterCapability printerCapability;
467 Json::Value capsJson;
468 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
469 EXPECT_EQ(capsJson["colorMode"].asInt(), 0);
470 }
471
472 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0028_NeedRename, TestSize.Level1)
473 {
474 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
475 EXPECT_NE(systemData, nullptr);
476 PrinterCapability printerCapability;
477 PrintMargin minMargin;
478 printerCapability.SetMinMargin(minMargin);
479 std::vector<PrintResolution> resolutionList;
480 printerCapability.SetResolution(resolutionList);
481 std::string ops = "test";
482 printerCapability.SetOption(ops);
483 Json::Value capsJson;
484 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
485 EXPECT_EQ(capsJson["colorMode"].asInt(), 0);
486 }
487
488 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0029_NeedRename, TestSize.Level1)
489 {
490 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
491 EXPECT_NE(systemData, nullptr);
492 PrinterCapability printerCapability;
493 PrintMargin minMargin;
494 printerCapability.SetMinMargin(minMargin);
495 std::vector<PrintResolution> resolutionList;
496 printerCapability.SetResolution(resolutionList);
497 Json::Value ops;
498 ops["key"] = "value";
499 printerCapability.SetOption(PrintJsonUtil::WriteString(ops));
500 Json::Value capsJson;
501 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
502 EXPECT_EQ(capsJson["colorMode"].asInt(), 0);
503 }
504
505 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0030_NeedRename, TestSize.Level1)
506 {
507 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
508 EXPECT_NE(systemData, nullptr);
509 PrinterCapability printerCapability;
510 PrintMargin minMargin;
511 printerCapability.SetMinMargin(minMargin);
512 Json::Value capsJson;
513 systemData->ConvertPrintMarginToJson(printerCapability, capsJson);
514 EXPECT_EQ(capsJson["minMargin"].isNull(), true);
515 }
516
517 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0031_NeedRename, 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 EXPECT_EQ(capsJson["minMargin"]["top"].asInt(), 100);
531 }
532
533 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0032_NeedRename, TestSize.Level1)
534 {
535 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
536 EXPECT_NE(systemData, nullptr);
537 Json::Value capsJson;
538 PrinterCapability printerCapability;
539 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
540 capsJson["colorMode"] = "string";
541 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
542 capsJson["colorMode"] = 123;
543 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
544 capsJson["duplexMode"] = "string";
545 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
546 capsJson["duplexMode"] = 123;
547 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
548 Json::Value marginJson;
549 capsJson["minMargin"] = marginJson;
550 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
551 Json::Value marginJson2;
552 capsJson["minMargin"] = marginJson2;
553 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
554 Json::Value pageSizeJson;
555 capsJson["pageSize"] = pageSizeJson;
556 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
557 Json::Value pageSizeJson2;
558 Json::Value pageSize;
559 pageSizeJson2.append(pageSize);
560 capsJson["pageSize"] = pageSizeJson2;
561 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
562 Json::Value pageSizeJson3;
563 capsJson["pageSize"] = pageSizeJson3;
564 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
565 Json::Value resolutionJson;
566 capsJson["resolution"] = resolutionJson;
567 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
568 Json::Value resolutionJson2;
569 Json::Value resolution;
570 resolutionJson2.append(resolution);
571 capsJson["resolution"] = resolutionJson2;
572 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
573 Json::Value resolutionJson3;
574 capsJson["resolution"] = resolutionJson3;
575 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
576 Json::Value opsJson;
577 capsJson["options"] = opsJson;
578 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
579 Json::Value opsJson2;
580 capsJson["options"] = opsJson2;
581 systemData->ConvertJsonToPrinterCapability(capsJson, printerCapability);
582 EXPECT_EQ(printerCapability.GetColorMode(), 123);
583 }
584
585 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0033_NeedRename, TestSize.Level1)
586 {
587 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
588 EXPECT_NE(systemData, nullptr);
589 Json::Value capsJson;
590 PrinterCapability printerCapability;
591 Json::Value resolutionListJson;
592 Json::Value resolutionItem;
593 resolutionListJson.append(resolutionItem);
594 capsJson["resolution"] = resolutionListJson;
595 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
596 Json::Value resolutionListJson2;
597 Json::Value resolutionItem2;
598 resolutionListJson2.append(resolutionItem2);
599 capsJson["resolution"] = resolutionListJson2;
600 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
601 Json::Value resolutionListJson3;
602 Json::Value resolutionItem3;
603 resolutionItem3["id"] = 123;
604 resolutionListJson3.append(resolutionItem3);
605 capsJson["resolution"] = resolutionListJson3;
606 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
607 Json::Value resolutionListJson4;
608 Json::Value resolutionItem4;
609 resolutionItem4["id"] = "123";
610 resolutionListJson4.append(resolutionItem4);
611 capsJson["resolution"] = resolutionListJson4;
612 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
613 std::vector<PrintResolution> resolutionList;
614 printerCapability.GetResolution(resolutionList);
615 EXPECT_EQ(resolutionList.size(), 0);
616 }
617
618 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0034_NeedRename, TestSize.Level1)
619 {
620 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
621 EXPECT_NE(systemData, nullptr);
622 Json::Value capsJson;
623 PrinterCapability printerCapability;
624 Json::Value resolutionListJson;
625 Json::Value resolutionItem;
626 resolutionItem["id"] = "123";
627 resolutionItem["horizontalDpi"] = "123";
628 resolutionListJson.append(resolutionItem);
629 capsJson["resolution"] = resolutionListJson;
630 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
631 Json::Value resolutionListJson2;
632 Json::Value resolutionItem2;
633 resolutionItem2["id"] = "123";
634 resolutionItem2["horizontalDpi"] = 123;
635 resolutionListJson2.append(resolutionItem2);
636 capsJson["resolution"] = resolutionListJson2;
637 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
638 Json::Value resolutionListJson3;
639 Json::Value resolutionItem3;
640 resolutionItem3["id"] = "123";
641 resolutionItem3["horizontalDpi"] = 123;
642 resolutionItem3["verticalDpi"] = "123";
643 resolutionListJson3.append(resolutionItem3);
644 capsJson["resolution"] = resolutionListJson3;
645 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
646 Json::Value resolutionListJson4;
647 Json::Value resolutionItem4;
648 resolutionItem4["id"] = "123";
649 resolutionItem4["horizontalDpi"] = 123;
650 resolutionItem4["verticalDpi"] = 123;
651 resolutionListJson4.append(resolutionItem4);
652 capsJson["resolution"] = resolutionListJson4;
653 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
654 std::vector<PrintResolution> resolutionList;
655 printerCapability.GetResolution(resolutionList);
656 EXPECT_EQ(resolutionList.size(), 1);
657 }
658
659 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0035_NeedRename, TestSize.Level1)
660 {
661 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
662 EXPECT_NE(systemData, nullptr);
663 Json::Value capsJson;
664 PrinterCapability printerCapability;
665 Json::Value resolutionListJson;
666 capsJson["resolution"] = resolutionListJson;
667 systemData->ConvertJsonToPrintResolution(capsJson, printerCapability);
668 std::vector<PrintResolution> resolutionList;
669 printerCapability.GetResolution(resolutionList);
670 EXPECT_EQ(resolutionList.size(), 0);
671 }
672
673 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0036_NeedRename, TestSize.Level1)
674 {
675 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
676 EXPECT_NE(systemData, nullptr);
677 Json::Value capsJson;
678 PrinterCapability printerCapability;
679 Json::Value pageSizeListJson;
680 capsJson["pageSize"] = pageSizeListJson;
681 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
682
683 Json::Value pageSizeListJson2;
684 Json::Value pageSizeItem2;
685 pageSizeListJson2.append(pageSizeItem2);
686 capsJson["pageSize"] = pageSizeListJson2;
687 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
688
689 Json::Value pageSizeListJson3;
690 Json::Value pageSizeItem3;
691 pageSizeItem3["id"] = 123;
692 pageSizeListJson3.append(pageSizeItem3);
693 capsJson["pageSize"] = pageSizeListJson3;
694 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
695
696 Json::Value pageSizeListJson4;
697 Json::Value pageSizeItem4;
698 pageSizeItem4["id"] = "123";
699 pageSizeListJson4.append(pageSizeItem4);
700 capsJson["pageSize"] = pageSizeListJson4;
701 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
702 std::vector<PrintPageSize> supportedPageSizeList;
703 printerCapability.GetSupportedPageSize(supportedPageSizeList);
704 EXPECT_EQ(supportedPageSizeList.size(), 0);
705 }
706
707 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0037_NeedRename, TestSize.Level1)
708 {
709 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
710 EXPECT_NE(systemData, nullptr);
711 Json::Value capsJson;
712 PrinterCapability printerCapability;
713 Json::Value pageSizeListJson;
714 Json::Value pageSizeItem;
715 pageSizeItem["id"] = "123";
716 pageSizeItem["name"] = 123;
717 pageSizeListJson.append(pageSizeItem);
718 capsJson["pageSize"] = pageSizeListJson;
719 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
720
721 Json::Value pageSizeListJson2;
722 Json::Value pageSizeItem2;
723 pageSizeItem2["id"] = "123";
724 pageSizeItem2["name"] = "123";
725 pageSizeListJson2.append(pageSizeItem2);
726 capsJson["pageSize"] = pageSizeListJson2;
727 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
728
729 Json::Value pageSizeListJson3;
730 Json::Value pageSizeItem3;
731 pageSizeItem3["id"] = "123";
732 pageSizeItem3["name"] = "123";
733 pageSizeItem3["width"] = "123";
734 pageSizeListJson3.append(pageSizeItem3);
735 capsJson["pageSize"] = pageSizeListJson3;
736 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
737
738 Json::Value pageSizeListJson4;
739 Json::Value pageSizeItem4;
740 pageSizeItem4["id"] = "123";
741 pageSizeItem4["name"] = "123";
742 pageSizeItem4["width"] = 123;
743 pageSizeListJson4.append(pageSizeItem4);
744 capsJson["pageSize"] = pageSizeListJson4;
745 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
746 std::vector<PrintPageSize> supportedPageSizeList;
747 printerCapability.GetSupportedPageSize(supportedPageSizeList);
748 EXPECT_EQ(supportedPageSizeList.size(), 0);
749 }
750
751 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0038_NeedRename, TestSize.Level1)
752 {
753 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
754 EXPECT_NE(systemData, nullptr);
755 Json::Value capsJson;
756 PrinterCapability printerCapability;
757 Json::Value pageSizeListJson;
758 Json::Value pageSizeItem;
759 pageSizeItem["id"] = "123";
760 pageSizeItem["name"] = "123";
761 pageSizeItem["width"] = 123;
762 pageSizeItem["height"] = "123";
763 pageSizeListJson.append(pageSizeItem);
764 capsJson["pageSize"] = pageSizeListJson;
765 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
766
767 Json::Value pageSizeListJson2;
768 Json::Value pageSizeItem2;
769 pageSizeItem2["id"] = "123";
770 pageSizeItem2["name"] = "123";
771 pageSizeItem2["width"] = 123;
772 pageSizeItem2["height"] = 123;
773 pageSizeListJson2.append(pageSizeItem2);
774 capsJson["pageSize"] = pageSizeListJson2;
775 systemData->ConvertJsonToPageSize(capsJson, printerCapability);
776 std::vector<PrintPageSize> supportedPageSizeList;
777 printerCapability.GetSupportedPageSize(supportedPageSizeList);
778 EXPECT_EQ(supportedPageSizeList.size(), 1);
779 }
780
781 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0039_NeedRename, TestSize.Level1)
782 {
783 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
784 EXPECT_NE(systemData, nullptr);
785 Json::Value capsJson;
786 PrinterCapability printerCapability;
787 Json::Value marginJson;
788 capsJson["minMargin"] = marginJson;
789 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
790
791 Json::Value marginJson2;
792 marginJson2["top"] = "123";
793 capsJson["minMargin"] = marginJson2;
794 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
795
796 Json::Value marginJson3;
797 marginJson3["top"] = 123;
798 capsJson["minMargin"] = marginJson3;
799 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
800
801 Json::Value marginJson4;
802 marginJson4["top"] = 123;
803 marginJson4["bottom"] = "123";
804 capsJson["minMargin"] = marginJson4;
805 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
806
807 Json::Value marginJson5;
808 marginJson5["top"] = 123;
809 marginJson5["bottom"] = 123;
810 capsJson["minMargin"] = marginJson5;
811 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
812
813 Json::Value marginJson6;
814 marginJson6["top"] = 123;
815 marginJson6["bottom"] = 123;
816 marginJson6["left"] = "123";
817 capsJson["minMargin"] = marginJson6;
818 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
819
820 Json::Value marginJson7;
821 marginJson7["top"] = 123;
822 marginJson7["bottom"] = 123;
823 marginJson7["left"] = 123;
824 capsJson["minMargin"] = marginJson7;
825 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
826 PrintMargin margin;
827 printerCapability.GetMinMargin(margin);
828 EXPECT_EQ(margin.GetTop(), 0);
829 }
830
831 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0040_NeedRename, TestSize.Level1)
832 {
833 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
834 EXPECT_NE(systemData, nullptr);
835 Json::Value capsJson;
836 PrinterCapability printerCapability;
837 Json::Value marginJson;
838 marginJson["top"] = 123;
839 marginJson["bottom"] = 123;
840 marginJson["left"] = 123;
841 marginJson["right"] = "123";
842 capsJson["minMargin"] = marginJson;
843 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
844
845 Json::Value marginJson2;
846 marginJson2["top"] = 123;
847 marginJson2["bottom"] = 123;
848 marginJson2["left"] = 123;
849 marginJson2["right"] = 123;
850 capsJson["minMargin"] = marginJson2;
851 systemData->ConvertJsonToPrintMargin(capsJson, printerCapability);
852 PrintMargin margin;
853 printerCapability.GetMinMargin(margin);
854 EXPECT_EQ(margin.GetTop(), 123);
855 }
856
857 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0041_NeedRename, TestSize.Level1)
858 {
859 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
860 EXPECT_NE(systemData, nullptr);
861 PrinterInfo printer;
862 std::string printerId = "123";
863 PrinterCapability printerCapability;
864 EXPECT_EQ(systemData->GetPrinterCapabilityFromSystemData(printer, printerId, printerCapability), false);
865 }
866
867 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0042_NeedRename, TestSize.Level1)
868 {
869 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
870 EXPECT_NE(systemData, nullptr);
871 PrinterInfo printer;
872 std::string printerId = "123";
873 PrinterCapability printerCapability;
874 PrinterCapability printerCapability2;
875 Json::Value opsJson;
876 opsJson["key"] = "value";
877 printerCapability2.SetOption(PrintJsonUtil::WriteString(opsJson));
878 std::vector<PrintPageSize> pageSizeList;
879 PrintPageSize pageSize;
880 pageSizeList.push_back(pageSize);
881 printerCapability2.SetSupportedPageSize(pageSizeList);
882 printer.SetCapability(printerCapability2);
883 systemData->GetPrinterCapabilityFromSystemData(printer, printerId, printerCapability);
884 EXPECT_EQ(systemData->GetPrinterCapabilityFromSystemData(printer, printerId, printerCapability), false);
885 }
886
887 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0043_NeedRename, TestSize.Level1)
888 {
889 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
890 EXPECT_NE(systemData, nullptr);
891 Json::Value object;
892 std::string printerId = "123";
893 EXPECT_EQ(systemData->CheckPrinterInfoJson(object, printerId), false);
894 }
895
896 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0044_NeedRename, TestSize.Level1)
897 {
898 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
899 EXPECT_NE(systemData, nullptr);
900 Json::Value object;
901 object["id"] = 123;
902 std::string printerId = "123";
903 systemData->CheckPrinterInfoJson(object, printerId);
904
905 Json::Value object2;
906 object2["id"] = "12";
907 systemData->CheckPrinterInfoJson(object2, printerId);
908
909 Json::Value object3;
910 object3["id"] = "123";
911 systemData->CheckPrinterInfoJson(object3, printerId);
912
913 Json::Value object4;
914 object4["id"] = "123";
915 object4["name"] = 123;
916 systemData->CheckPrinterInfoJson(object4, printerId);
917
918 Json::Value object5;
919 object5["id"] = "123";
920 object5["name"] = "123";
921 systemData->CheckPrinterInfoJson(object5, printerId);
922
923 Json::Value object6;
924 object6["id"] = "123";
925 object6["name"] = "123";
926 object6["uri"] = 123;
927 systemData->CheckPrinterInfoJson(object6, printerId);
928
929 Json::Value object7;
930 object7["id"] = "123";
931 object7["name"] = "123";
932 object7["uri"] = "123";
933 EXPECT_EQ(systemData->CheckPrinterInfoJson(object7, printerId), false);
934 }
935
936 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0045_NeedRename, TestSize.Level1)
937 {
938 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
939 EXPECT_NE(systemData, nullptr);
940 Json::Value object;
941 object["id"] = "123";
942 object["name"] = "123";
943 object["uri"] = "123";
944 object["maker"] = 123;
945 std::string printerId = "123";
946 systemData->CheckPrinterInfoJson(object, printerId);
947
948 Json::Value object2;
949 object2["id"] = "123";
950 object2["name"] = "123";
951 object2["uri"] = "123";
952 object2["maker"] = "123";
953 systemData->CheckPrinterInfoJson(object2, printerId);
954
955 Json::Value object3;
956 object3["id"] = "123";
957 object3["name"] = "123";
958 object3["uri"] = "123";
959 object3["maker"] = "123";
960 object3["capability"] = "123";
961 systemData->CheckPrinterInfoJson(object3, printerId);
962
963 Json::Value object4;
964 object4["id"] = "123";
965 object4["name"] = "123";
966 object4["uri"] = "123";
967 object4["maker"] = "123";
968 Json::Value capsJson;
969 object4["capability"] = capsJson;
970 EXPECT_EQ(systemData->CheckPrinterInfoJson(object4, printerId), false);
971 }
972
973 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0046_NeedRename, TestSize.Level1)
974 {
975 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
976 EXPECT_NE(systemData, nullptr);
977 std::string printerId = "123";
978 systemData->IsPrinterAdded(printerId);
979 systemData->addedPrinterMap_.Insert("123", nullptr);
980 systemData->IsPrinterAdded(printerId);
981 PrinterInfo printerInfo;
982 printerInfo.SetPrinterName("Direct");
983 printerInfo.SetUri("123");
984 printerInfo.SetPrinterMake("print");
985 systemData->addedPrinterMap_.Insert("123", std::make_shared<PrinterInfo>(printerInfo));
986 EXPECT_EQ(systemData->IsPrinterAdded(printerId), false);
987 }
988
989 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0047_NeedRename, TestSize.Level1)
990 {
991 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
992 EXPECT_NE(systemData, nullptr);
993 std::string printerId = "1234";
994 PrinterInfo printerInfo;
995 systemData->QueryPrinterInfoById(printerId, printerInfo);
996 PrinterInfo printerInfo1;
997 printerInfo1.SetPrinterName("Direct Pixlab1620");
998 printerInfo1.SetUri("123");
999 printerInfo1.SetPrinterMake("print");
1000 systemData->addedPrinterMap_.Insert("1234", std::make_shared<PrinterInfo>(printerInfo1));
1001 systemData->QueryPrinterInfoById(printerId, printerInfo);
1002 EXPECT_EQ(printerInfo.GetUri(), "123");
1003 }
1004
1005 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0048_NeedRename, TestSize.Level1)
1006 {
1007 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1008 EXPECT_NE(systemData, nullptr);
1009 std::string printerId;
1010 Json::Value jsonObject;
1011 PrinterCapability printerCapability;
1012 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1013
1014 Json::Value printerMapJson;
1015 jsonObject["printer_list"] = printerMapJson;
1016 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1017
1018 Json::Value jsonObject2;
1019 Json::Value printerMapJson2;
1020 jsonObject2["printer_list"] = printerMapJson2;
1021 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject2, printerCapability);
1022
1023 Json::Value jsonObject3;
1024 Json::Value printerMapJson3;
1025 Json::Value item;
1026 item["key"] = "value";
1027 printerMapJson3.append(item);
1028 jsonObject3["printer_list"] = printerMapJson3;
1029 EXPECT_EQ(systemData->GetPrinterCapabilityFromJson(printerId, jsonObject3, printerCapability), false);
1030 }
1031
1032 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0049_NeedRename, TestSize.Level1)
1033 {
1034 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1035 EXPECT_NE(systemData, nullptr);
1036 std::string printerId;
1037 PrinterCapability printerCapability;
1038 Json::Value jsonObject;
1039 Json::Value printerMapJson;
1040 Json::Value item;
1041 item["id"] = "123";
1042 item["name"] = "123";
1043 item["uri"] = "123";
1044 item["maker"] = "123";
1045 Json::Value capsJson;
1046 capsJson["key"] = "value";
1047 item["capability"] = capsJson;
1048 printerMapJson.append(item);
1049 jsonObject["printer_list"] = printerMapJson;
1050 EXPECT_EQ(systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability), false);
1051 }
1052
1053 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0050_NeedRename, TestSize.Level1)
1054 {
1055 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1056 EXPECT_NE(systemData, nullptr);
1057 std::string printerId;
1058 PrinterCapability printerCapability;
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 EXPECT_EQ(systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability), false);
1072 }
1073
1074 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0051_NeedRename, TestSize.Level1)
1075 {
1076 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1077 EXPECT_NE(systemData, nullptr);
1078 std::string printerId = "123";
1079 PrinterCapability printerCapability;
1080 std::vector<PrintPageSize> pageSizeList;
1081 PrintPageSize pageSize;
1082 pageSizeList.push_back(pageSize);
1083 printerCapability.SetSupportedPageSize(pageSizeList);
1084 Json::Value opsJson;
1085 opsJson["printerName"] = "123";
1086 printerCapability.SetOption(PrintJsonUtil::WriteString(opsJson));
1087 Json::Value jsonObject;
1088 Json::Value printerMapJson;
1089 Json::Value item;
1090 item["id"] = "123";
1091 item["name"] = "123";
1092 item["uri"] = "123";
1093 item["maker"] = "123";
1094 Json::Value capsJson;
1095 systemData->ConvertPrinterCapabilityToJson(printerCapability, capsJson);
1096 item["capability"] = capsJson;
1097 printerMapJson.append(item);
1098 jsonObject["printer_list"] = printerMapJson;
1099 systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability);
1100 EXPECT_EQ(systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability), false);
1101 }
1102
1103 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0052_NeedRename, TestSize.Level1)
1104 {
1105 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1106 EXPECT_NE(systemData, nullptr);
1107 std::string printerId = "";
1108 std::string printerName = "";
1109 systemData->DeleteAddedPrinter(printerId, printerName);
1110 EXPECT_EQ(systemData->addedPrinterMap_.GetKeyList().size(), 0);
1111 }
1112
1113 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0053_NeedRename, TestSize.Level1)
1114 {
1115 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1116 EXPECT_NE(systemData, nullptr);
1117 std::string printerId = "1234";
1118 std::string printerAlias = "1234";
1119 systemData->UpdatePrinterAlias(printerId, printerAlias);
1120
1121 PrinterInfo printerInfo;
1122 printerInfo.SetAlias(printerAlias);
1123 systemData->addedPrinterMap_.Insert(printerId, std::make_shared<PrinterInfo>(printerInfo));
1124
1125 bool ret = systemData->UpdatePrinterAlias(printerId, "");
1126 EXPECT_EQ(ret, true);
1127
1128 systemData->UpdatePrinterAlias(printerId, printerAlias);
1129 }
1130
1131 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0054_NeedRename, TestSize.Level1)
1132 {
1133 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1134 EXPECT_NE(systemData, nullptr);
1135 std::string printerId1 = "1";
1136 PrinterInfo printerInfo1;
1137 systemData->addedPrinterMap_.Insert(printerId1, std::make_shared<PrinterInfo>(printerInfo1));
1138 systemData->CheckPrinterBusy(printerId1);
1139
1140 std::string printerId2 = "2";
1141 PrinterInfo printerInfo2;
1142 printerInfo2.SetPrinterStatus(PRINTER_STATUS_BUSY);
1143 systemData->addedPrinterMap_.Insert(printerId2, std::make_shared<PrinterInfo>(printerInfo2));
1144 bool ret = systemData->CheckPrinterBusy(printerId2);
1145 EXPECT_EQ(ret, true);
1146 }
1147
1148 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0055_NeedRename, TestSize.Level1)
1149 {
1150 auto systemData = std::make_shared<PrintSystemData>();
1151 EXPECT_NE(systemData, nullptr);
1152 std::string printerId1 = "1";
1153 std::string printerId2 = "2";
1154 std::string printerName = "name";
1155 auto printerInfo = std::make_shared<PrinterInfo>();
1156 EXPECT_NE(printerInfo, nullptr);
1157 printerInfo->SetPrinterId(printerId1);
1158 printerInfo->SetPrinterName(printerName);
1159 systemData->AddPrinterToDiscovery(printerInfo);
1160 EXPECT_EQ(systemData->GetDiscoveredPrinterCount(), 1);
1161 auto discoveredPrinter = systemData->QueryDiscoveredPrinterInfoById(printerId1);
1162 EXPECT_NE(discoveredPrinter, nullptr);
1163 discoveredPrinter = systemData->QueryDiscoveredPrinterInfoById(printerId2);
1164 EXPECT_EQ(discoveredPrinter, nullptr);
1165 discoveredPrinter = systemData->QueryDiscoveredPrinterInfoByName(printerName);
1166 EXPECT_NE(discoveredPrinter, nullptr);
1167 discoveredPrinter = systemData->QueryDiscoveredPrinterInfoByName(printerId2);
1168 EXPECT_EQ(discoveredPrinter, nullptr);
1169 systemData->RemovePrinterFromDiscovery(printerId1);
1170 EXPECT_EQ(systemData->GetDiscoveredPrinterCount(), 0);
1171 systemData->ClearDiscoveredPrinterList();
1172 }
1173
1174 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0056_NeedRename, TestSize.Level1) {
1175 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1176 EXPECT_NE(systemData, nullptr);
1177 PrinterCapability printerCapability;
1178 std::vector<uint32_t> supportedColorModeList;
1179 supportedColorModeList.push_back(1);
1180 printerCapability.SetSupportedColorMode(supportedColorModeList);
1181 Json::Value capsJson;
1182 systemData->ConvertSupportedColorModeToJson(printerCapability, capsJson);
1183 EXPECT_EQ(capsJson["supportedColorMode"].isNull(), false);
1184 }
1185
1186 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0057_NeedRename, TestSize.Level1) {
1187 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1188 EXPECT_NE(systemData, nullptr);
1189 PrinterCapability printerCapability;
1190 std::vector<uint32_t> supportedDuplexModeList;
1191 supportedDuplexModeList.push_back(1);
1192 printerCapability.SetSupportedDuplexMode(supportedDuplexModeList);
1193 Json::Value capsJson;
1194 systemData->ConvertSupportedDuplexModeToJson(printerCapability, capsJson);
1195 EXPECT_EQ(capsJson["supportedDuplexMode"].isNull(), false);
1196 }
1197
1198 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0058_NeedRename, TestSize.Level1) {
1199 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1200 EXPECT_NE(systemData, nullptr);
1201 PrinterCapability printerCapability;
1202 std::vector<std::string> supportedMediaTypeList;
1203 supportedMediaTypeList.push_back("type1");
1204 printerCapability.SetSupportedMediaType(supportedMediaTypeList);
1205 Json::Value capsJson;
1206 systemData->ConvertSupportedMediaTypeToJson(printerCapability, capsJson);
1207 EXPECT_EQ(capsJson["supportedMediaType"].isNull(), false);
1208 }
1209
1210 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0059_NeedRename, TestSize.Level1) {
1211 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1212 EXPECT_NE(systemData, nullptr);
1213 PrinterCapability printerCapability;
1214 std::vector<uint32_t> supportedQualityList;
1215 supportedQualityList.push_back(1);
1216 printerCapability.SetSupportedQuality(supportedQualityList);
1217 Json::Value capsJson;
1218 systemData->ConvertSupportedQualityToJson(printerCapability, capsJson);
1219 EXPECT_EQ(capsJson["supportedQuality"].isNull(), false);
1220 }
1221
1222 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0060_NeedRename, TestSize.Level1)
1223 {
1224 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1225 EXPECT_NE(systemData, nullptr);
1226 PrinterInfo info;
1227 Json::Value printerJson;
1228 systemData->ConvertInnerJsonToPrinterInfo(printerJson, info);
1229 printerJson["alias"] = 123;
1230 printerJson["printerStatus"] = "132";
1231 printerJson["preferences"] = "123";
1232 systemData->ConvertInnerJsonToPrinterInfo(printerJson, info);
1233 printerJson["alias"] = "123";
1234 printerJson["printerStatus"] = 123;
1235 Json::Value preferencesJson;
1236 printerJson["preferences"] = preferencesJson;
1237 systemData->ConvertInnerJsonToPrinterInfo(printerJson, info);
1238 EXPECT_EQ(info.GetAlias(), printerJson["alias"].asString());
1239 EXPECT_EQ(info.GetPrinterStatus(), static_cast<PrinterStatus>(printerJson["printerStatus"].asInt()));
1240 }
1241
1242 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0061_NeedRename, TestSize.Level1)
1243 {
1244 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1245 EXPECT_NE(systemData, nullptr);
1246 Json::Value jsonObject;
1247 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), false);
1248 }
1249
1250 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0062_NeedRename, TestSize.Level1)
1251 {
1252 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1253 EXPECT_NE(systemData, nullptr);
1254 PrinterPreferences preferences;
1255 Json::Value settingJson;
1256 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), false);
1257 }
1258
1259 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0063_NeedRename, TestSize.Level1)
1260 {
1261 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1262 EXPECT_NE(systemData, nullptr);
1263 PrinterPreferences preferences;
1264 Json::Value settingJson;
1265 settingJson["pagesizeId"] = 123;
1266 settingJson["orientation"] = 123;
1267 settingJson["duplex"] = 123;
1268 settingJson["quality"] = 123;
1269 settingJson["mediaType"] = 123;
1270 settingJson["hasMargin"] = "123";
1271 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), false);
1272 }
1273
1274 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0064_NeedRename, TestSize.Level1)
1275 {
1276 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1277 EXPECT_NE(systemData, nullptr);
1278 PrinterPreferences preferences;
1279 Json::Value settingJson;
1280 settingJson["pagesizeId"] = "";
1281 settingJson["orientation"] = "";
1282 settingJson["duplex"] = "";
1283 settingJson["quality"] = "";
1284 settingJson["mediaType"] = "";
1285 settingJson["hasMargin"] = true;
1286 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), false);
1287 }
1288
1289 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0065_NeedRename, TestSize.Level1)
1290 {
1291 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1292 EXPECT_NE(systemData, nullptr);
1293 PrinterPreferences preferences;
1294 Json::Value settingJson;
1295 settingJson["pagesizeId"] = "123";
1296 settingJson["orientation"] = "123";
1297 settingJson["duplex"] = "123";
1298 settingJson["quality"] = "123";
1299 settingJson["mediaType"] = "123";
1300 settingJson["hasMargin"] = false;
1301 EXPECT_EQ(systemData->ParsePreviousPreferencesSetting(settingJson, preferences), true);
1302 }
1303
1304 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0066_NeedRename, TestSize.Level1)
1305 {
1306 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1307 EXPECT_NE(systemData, nullptr);
1308 std::string printerId = "1234";
1309 PrinterPreferences preferences;
1310 preferences.SetBorderless(true);
1311 systemData->UpdatePrinterPreferences(printerId, preferences);
1312
1313 PrinterInfo printerInfo;
1314 printerInfo.SetPreferences(preferences);
1315 systemData->addedPrinterMap_.Insert(printerId, std::make_shared<PrinterInfo>(printerInfo));
1316 systemData->UpdatePrinterPreferences(printerId, preferences);
1317 PrinterInfo printer;
1318 systemData->QueryAddedPrinterInfoByPrinterId(printerId, printer);
1319 PrinterPreferences preferences1;
1320 printer.GetPreferences(preferences1);
1321 EXPECT_EQ(preferences1.GetBorderless(), preferences.GetBorderless());
1322 }
1323
1324 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0070_NeedRename, TestSize.Level1)
1325 {
1326 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1327 EXPECT_NE(systemData, nullptr);
1328 PrinterPreferences preferences;
1329 PrinterCapability cap;
1330 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_NONE);
1331 }
1332
1333 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0071_NeedRename, TestSize.Level1)
1334 {
1335 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1336 EXPECT_NE(systemData, nullptr);
1337 PrinterPreferences preferences;
1338 PrinterCapability cap;
1339 cap.SetOption("test");
1340 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_NONE);
1341 }
1342
1343 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0072_NeedRename, TestSize.Level1)
1344 {
1345 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1346 EXPECT_NE(systemData, nullptr);
1347 PrinterPreferences preferences;
1348 PrinterCapability cap;
1349 Json::Value optionJson;
1350 optionJson["key"] = "value";
1351 cap.SetOption(PrintJsonUtil::WriteString(optionJson));
1352 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_NONE);
1353 }
1354
1355 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0073_NeedRename, TestSize.Level1)
1356 {
1357 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1358 EXPECT_NE(systemData, nullptr);
1359 PrinterPreferences preferences;
1360 PrinterCapability cap;
1361 Json::Value optionJson;
1362 optionJson["cupsOptions"] = "value";
1363 cap.SetOption(PrintJsonUtil::WriteString(optionJson));
1364 EXPECT_EQ(systemData->BuildPrinterPreference(cap, preferences), E_PRINT_NONE);
1365 }
1366
1367 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0074_NeedRename, TestSize.Level1)
1368 {
1369 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1370 EXPECT_NE(systemData, nullptr);
1371 PrinterCapability cap;
1372 EXPECT_EQ(systemData->ParseDefaultPageSizeId(cap), "");
1373 }
1374
1375 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0075_NeedRename, TestSize.Level1)
1376 {
1377 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1378 EXPECT_NE(systemData, nullptr);
1379 PrinterCapability cap;
1380 std::vector<PrintPageSize> supportedPageSize;
1381 PrintPageSize pageSize1;
1382 pageSize1.SetId("ISO_A3");
1383 PrintPageSize pageSize2;
1384 pageSize2.SetId("ISO_A4");
1385 supportedPageSize.emplace_back(pageSize1);
1386 supportedPageSize.emplace_back(pageSize2);
1387 cap.SetSupportedPageSize(supportedPageSize);
1388 EXPECT_EQ(systemData->ParseDefaultPageSizeId(cap), "ISO_A3");
1389 }
1390
1391 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0090_NeedRename, TestSize.Level1)
1392 {
1393 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1394 EXPECT_NE(systemData, nullptr);
1395 Json::Value jsonObject;
1396 Json::Value printerListJson;
1397 jsonObject["printer_list"] = printerListJson;
1398 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), false);
1399 }
1400
1401 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0091_NeedRename, TestSize.Level1)
1402 {
1403 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1404 EXPECT_NE(systemData, nullptr);
1405 Json::Value jsonObject;
1406 Json::Value printerListJson;
1407 std::string printerId = "testPrinterId";
1408 Json::Value printer;
1409 Json::Value printPreferenceJson;
1410 printer[printerId] = printPreferenceJson;
1411 printerListJson.append(printer);
1412 jsonObject["printer_list"] = printerListJson;
1413 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1414 }
1415
1416 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0092_NeedRename, TestSize.Level1)
1417 {
1418 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1419 EXPECT_NE(systemData, nullptr);
1420 Json::Value jsonObject;
1421 Json::Value printerListJson;
1422 std::string printerId = "testPrinterId";
1423 Json::Value printer;
1424 Json::Value printPreferenceJson;
1425 Json::Value setting;
1426 printPreferenceJson["setting"] = setting;
1427 printer[printerId] = printPreferenceJson;
1428 printerListJson.append(printer);
1429 jsonObject["printer_list"] = printerListJson;
1430 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1431 }
1432
1433 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0093_NeedRename, TestSize.Level1)
1434 {
1435 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1436 EXPECT_NE(systemData, nullptr);
1437 Json::Value jsonObject;
1438 Json::Value printerListJson;
1439 std::string printerId = "testPrinterId";
1440 Json::Value printer;
1441 Json::Value printPreferenceJson;
1442 Json::Value setting;
1443 printPreferenceJson["setting"] = setting;
1444 printer[printerId] = printPreferenceJson;
1445 printerListJson.append(printer);
1446 jsonObject["printer_list"] = printerListJson;
1447 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1448 }
1449
1450 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0094_NeedRename, TestSize.Level1)
1451 {
1452 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1453 EXPECT_NE(systemData, nullptr);
1454 Json::Value jsonObject;
1455 Json::Value printerListJson;
1456 std::string printerId = "testPrinterId";
1457 Json::Value printer;
1458 Json::Value printPreferenceJson;
1459 Json::Value setting;
1460 setting["pagesizeId"] = "ISO_A4";
1461 printPreferenceJson["setting"] = setting;
1462 printer[printerId] = printPreferenceJson;
1463 printerListJson.append(printer);
1464 jsonObject["printer_list"] = printerListJson;
1465 EXPECT_EQ(systemData->ParsePrinterPreferencesJson(jsonObject), true);
1466 }
1467
1468 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0095_NeedRename, TestSize.Level1)
1469 {
1470 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1471 EXPECT_NE(systemData, nullptr);
1472 std::string printerId = "testPrinterId";
1473 std::shared_ptr<PrinterInfo> printerInfo = std::make_shared<PrinterInfo>();
1474 printerInfo->SetPrinterId(printerId);
1475 systemData->connectingIpPrinterInfoList_[printerId] = printerInfo;
1476 EXPECT_EQ(systemData->QueryIpPrinterInfoById(printerId)->GetPrinterId(), printerId);
1477 }
1478
1479 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0096_NeedRename, TestSize.Level1)
1480 {
1481 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1482 EXPECT_NE(systemData, nullptr);
1483 systemData->AddIpPrinterToList(nullptr);
1484 EXPECT_EQ(systemData->connectingIpPrinterInfoList_.size(), 0);
1485 }
1486
1487 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0097_NeedRename, TestSize.Level1)
1488 {
1489 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1490 EXPECT_NE(systemData, nullptr);
1491 std::shared_ptr<PrinterInfo> printerInfo = std::make_shared<PrinterInfo>();
1492 systemData->AddIpPrinterToList(printerInfo);
1493 EXPECT_EQ(systemData->connectingIpPrinterInfoList_.size(), 1);
1494 }
1495
1496 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0098_NeedRename, TestSize.Level1)
1497 {
1498 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1499 EXPECT_NE(systemData, nullptr);
1500 std::vector<int32_t> allPrintUserList;
1501 Json::Value jsonObject;
1502 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), false);
1503 }
1504
1505 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0099_NeedRename, TestSize.Level1)
1506 {
1507 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1508 EXPECT_NE(systemData, nullptr);
1509 std::vector<int32_t> allPrintUserList;
1510 Json::Value jsonObject;
1511 Json::Value userDataJson;
1512 jsonObject["print_user_data"] = userDataJson;
1513 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), false);
1514 }
1515
1516 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0100_NeedRename, TestSize.Level1)
1517 {
1518 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1519 EXPECT_NE(systemData, nullptr);
1520 std::vector<int32_t> allPrintUserList;
1521 Json::Value jsonObject;
1522 Json::Value userDataJson;
1523 jsonObject["print_user_data"] = userDataJson;
1524 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), false);
1525 }
1526
1527 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0101_NeedRename, TestSize.Level1)
1528 {
1529 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1530 EXPECT_NE(systemData, nullptr);
1531 std::vector<int32_t> allPrintUserList;
1532 Json::Value jsonObject;
1533 Json::Value userDataJson;
1534 userDataJson[""] = "user1";
1535 userDataJson["100"] = "user2";
1536 jsonObject["print_user_data"] = userDataJson;
1537 EXPECT_EQ(systemData->ParseUserListJsonV1(jsonObject, allPrintUserList), true);
1538 }
1539
1540 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0102_NeedRename, TestSize.Level1)
1541 {
1542 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1543 EXPECT_NE(systemData, nullptr);
1544 std::string printerId = "123";
1545 PrinterCapability printerCapability;
1546 std::vector<PrintPageSize> pageSizeList;
1547 PrintPageSize pageSize;
1548 pageSizeList.push_back(pageSize);
1549 printerCapability.SetSupportedPageSize(pageSizeList);
1550 Json::Value opsJson;
1551 opsJson["printerName"] = "123";
1552 printerCapability.SetOption(PrintJsonUtil::WriteString(opsJson));
1553 Json::Value jsonObject;
1554 Json::Value printerMapJson;
1555 Json::Value item;
1556 item["id"] = "123";
1557 item["name"] = "123";
1558 item["uri"] = "123";
1559 item["maker"] = "123";
1560 printerMapJson.append(item);
1561 jsonObject["printer_list"] = printerMapJson;
1562 EXPECT_EQ(systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability), false);
1563 }
1564
1565 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0103_NeedRename, TestSize.Level1)
1566 {
1567 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1568 EXPECT_NE(systemData, nullptr);
1569 std::string printerId = "123";
1570 PrinterCapability printerCapability;
1571 std::vector<PrintPageSize> pageSizeList;
1572 PrintPageSize pageSize;
1573 pageSizeList.push_back(pageSize);
1574 printerCapability.SetSupportedPageSize(pageSizeList);
1575 Json::Value opsJson;
1576 opsJson["printerName"] = "123";
1577 printerCapability.SetOption(PrintJsonUtil::WriteString(opsJson));
1578 Json::Value jsonObject;
1579 Json::Value printerMapJson;
1580 Json::Value item;
1581 item["id"] = "123";
1582 item["name"] = "123";
1583 item["uri"] = "123";
1584 item["maker"] = "123";
1585 Json::Value capsJson;
1586 item["capability"] = capsJson;
1587 printerMapJson.append(item);
1588 jsonObject["printer_list"] = printerMapJson;
1589 EXPECT_EQ(systemData->GetPrinterCapabilityFromJson(printerId, jsonObject, printerCapability), false);
1590 }
1591
1592 HWTEST_F(PrintSystemDataTest, PrintSystemDataTest_0104_NeedRename, TestSize.Level1)
1593 {
1594 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1595 EXPECT_NE(systemData, nullptr);
1596 std::shared_ptr<PrinterInfo> printerInfo = std::make_shared<PrinterInfo>();
1597 std::string printerId = "1234";
1598 std::string uri = "testUri";
1599 printerInfo->SetPrinterId(printerId);
1600 printerInfo->SetUri(uri);
1601 systemData->UpdatePrinterUri(printerInfo);
1602
1603 PrinterInfo printerInfo1;
1604 systemData->addedPrinterMap_.Insert(printerId, std::make_shared<PrinterInfo>(printerInfo1));
1605 systemData->UpdatePrinterUri(printerInfo);
1606 PrinterInfo printer;
1607 systemData->QueryAddedPrinterInfoByPrinterId(printerId, printer);
1608 EXPECT_EQ(printer.GetUri(), uri);
1609 }
1610
1611 HWTEST_F(PrintSystemDataTest,
1612 BuildPrinterPreferenceByDefault_WrongTypeValueInJson_HasDefaultPageSizeIdReturnFalse, TestSize.Level1)
1613 {
1614 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1615 EXPECT_NE(systemData, nullptr);
1616 Json::Value capOpt;
1617 PrinterPreferences printPreferences;
1618 capOpt["defaultPageSizeId"] = 1;
1619 capOpt["orientation-requested-default"] = 1;
1620 capOpt["sides-default"] = 1;
1621 capOpt["print-quality-default"] = 1;
1622 capOpt["media-type-default"] = 1;
1623 capOpt["defaultColorMode"] = 1;
1624 capOpt["advanceDefault"] = 1;
1625 systemData->BuildPrinterPreferenceByDefault(capOpt, printPreferences);
1626 EXPECT_EQ(printPreferences.HasDefaultPageSizeId(), false);
1627 }
1628
1629 HWTEST_F(PrintSystemDataTest,
1630 BuildPrinterPreferenceByDefault_CorrectValueInJson_GetDefaultPageSizeIdReturnSameValue, TestSize.Level1)
1631 {
1632 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1633 EXPECT_NE(systemData, nullptr);
1634 Json::Value capOpt;
1635 PrinterPreferences printPreferences;
1636 capOpt["defaultPageSizeId"] = "ISO_A4";
1637 capOpt["orientation-requested-default"] = "1";
1638 capOpt["sides-default"] = "1";
1639 capOpt["print-quality-default"] = "1";
1640 capOpt["media-type-default"] = "plain";
1641 capOpt["defaultColorMode"] = "1";
1642 capOpt["advanceDefault"] = "1";
1643 systemData->BuildPrinterPreferenceByDefault(capOpt, printPreferences);
1644 EXPECT_EQ(printPreferences.GetDefaultPageSizeId(), "ISO_A4");
1645 }
1646
1647 HWTEST_F(PrintSystemDataTest, BuildPrinterPreferenceBySupport_SetValue_HasBorderlessReturnTrue, TestSize.Level1)
1648 {
1649 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1650 EXPECT_NE(systemData, nullptr);
1651 PrinterCapability cap;
1652 PrinterPreferences printPreferences;
1653 printPreferences.SetDefaultPageSizeId("ISO_A4");
1654 printPreferences.SetDefaultDuplexMode(0);
1655 printPreferences.SetDefaultPrintQuality(0);
1656 printPreferences.SetDefaultMediaType("plain");
1657 printPreferences.SetDefaultColorMode(0);
1658 systemData->BuildPrinterPreferenceBySupport(cap, printPreferences);
1659 EXPECT_EQ(printPreferences.HasBorderless(), true);
1660 }
1661
1662 HWTEST_F(PrintSystemDataTest, BuildPrinterPreferenceBySupport_SetCap_HasBorderlessReturnTrue, TestSize.Level1)
1663 {
1664 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1665 EXPECT_NE(systemData, nullptr);
1666 PrinterCapability cap;
1667 PrinterPreferences printPreferences;
1668 std::vector<uint32_t> supportedDuplexModeList;
1669 supportedDuplexModeList.emplace_back(0);
1670 cap.SetSupportedDuplexMode(supportedDuplexModeList);
1671 std::vector<uint32_t> supportedQualityList;
1672 supportedQualityList.emplace_back(0);
1673 cap.SetSupportedQuality(supportedQualityList);
1674 std::vector<std::string> supportedMediaTypeList;
1675 supportedMediaTypeList.emplace_back("plain");
1676 cap.SetSupportedMediaType(supportedMediaTypeList);
1677 std::vector<uint32_t> supportedColorModeList;
1678 supportedColorModeList.emplace_back(0);
1679 cap.SetSupportedColorMode(supportedColorModeList);
1680 systemData->BuildPrinterPreferenceBySupport(cap, printPreferences);
1681 EXPECT_EQ(printPreferences.HasBorderless(), true);
1682 }
1683
1684 HWTEST_F(PrintSystemDataTest,
1685 BuildPrinterPreferenceByDefault_SetPreferencesValue_GetDefaultPageSizeIdReturnSameValue, TestSize.Level1)
1686 {
1687 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1688 EXPECT_NE(systemData, nullptr);
1689 Json::Value capOpt;
1690 PrinterPreferences printPreferences;
1691 printPreferences.SetDefaultPageSizeId("ISO_A5");
1692 printPreferences.SetDefaultOrientation(PRINT_ORIENTATION_MODE_PORTRAIT);
1693 printPreferences.SetDefaultDuplexMode(DUPLEX_MODE_LONG_EDGE);
1694 printPreferences.SetDefaultPrintQuality(PRINT_QUALITY_DRAFT);
1695 printPreferences.SetDefaultMediaType("photo");
1696 capOpt["defaultPageSizeId"] = "ISO_A4";
1697 capOpt["orientation-requested-default"] = "1";
1698 capOpt["sides-default"] = "1";
1699 capOpt["print-quality-default"] = "1";
1700 capOpt["media-type-default"] = "plain";
1701 capOpt["defaultColorMode"] = "1";
1702 capOpt["advanceDefault"] = "1";
1703 systemData->BuildPrinterPreferenceByDefault(capOpt, printPreferences);
1704 EXPECT_EQ(printPreferences.GetDefaultPageSizeId(), "ISO_A5");
1705 }
1706
1707 HWTEST_F(PrintSystemDataTest,
1708 BuildPrinterPreferenceByDefault_NullValueInJson_HasDefaultPageSizeIdReturnfalse, TestSize.Level1)
1709 {
1710 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1711 EXPECT_NE(systemData, nullptr);
1712 Json::Value capOpt;
1713 PrinterPreferences printPreferences;
1714 systemData->BuildPrinterPreferenceByDefault(capOpt, printPreferences);
1715 EXPECT_EQ(printPreferences.HasDefaultPageSizeId(), false);
1716 }
1717
1718 HWTEST_F(PrintSystemDataTest, BuildPrinterPreferenceBySupport_NoValueSet_HasBorderlessReturnTrue, TestSize.Level1)
1719 {
1720 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1721 EXPECT_NE(systemData, nullptr);
1722 PrinterCapability cap;
1723 PrinterPreferences printPreferences;
1724 systemData->BuildPrinterPreferenceBySupport(cap, printPreferences);
1725 EXPECT_EQ(printPreferences.HasBorderless(), true);
1726 }
1727
1728 HWTEST_F(PrintSystemDataTest, CheckPrinterVersionFile_FileExist_ReturnTrue, TestSize.Level1)
1729 {
1730 auto systemData = std::make_shared<OHOS::Print::PrintSystemData>();
1731 systemData->CheckPrinterVersionFile();
1732 EXPECT_EQ(systemData->CheckPrinterVersionFile(), true);
1733 }
1734 } // namespace Print
1735 } // namespace OHOS
1736