• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <vector>
18 #include <string>
19 #include <map>
20 #include "printer_info.h"
21 #include "iprint_callback.h"
22 #define private public
23 #include "print_user_data.h"
24 #undef private
25 #include "print_constant.h"
26 #include "print_log.h"
27 #include "mock_print_callback_stub.h"
28 #include "print_json_util.h"
29 
30 using namespace testing::ext;
31 
32 namespace OHOS {
33 namespace Print {
34 
35 class PrintUserDataTest : public testing::Test {
36 public:
37     static void SetUpTestCase(void);
38     static void TearDownTestCase(void);
39     void SetUp();
40     void TearDown();
41 };
42 
SetUpTestCase(void)43 void PrintUserDataTest::SetUpTestCase(void) {}
44 
TearDownTestCase(void)45 void PrintUserDataTest::TearDownTestCase(void) {}
46 
SetUp(void)47 void PrintUserDataTest::SetUp(void)
48 {
49     static int32_t testNo = 0;
50     PRINT_HILOGI("PrintUserDataTest_%{public}d", ++testNo);
51 }
52 
TearDown(void)53 void PrintUserDataTest::TearDown(void) {}
54 
55 /**
56  * @tc.name: PrintServiceStubTest_0001
57  * @tc.desc: Verify the capability function.
58  * @tc.type: FUNC
59  * @tc.require:
60  */
61 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0001_NeedRename, TestSize.Level1)
62 {
63     std::string type = "111";
64     sptr<IPrintCallback> listener = nullptr;
65     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
66     userData->RegisterPrinterCallback(type, listener);
67     EXPECT_EQ(userData->registeredListeners_.size(), 1);
68 }
69 
70 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0002_NeedRename, TestSize.Level1)
71 {
72     std::string type = "111";
73     sptr<IPrintCallback> listener = nullptr;
74     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
75     userData->RegisterPrinterCallback(type, listener);
76     userData->UnregisterPrinterCallback(type);
77     EXPECT_EQ(userData->registeredListeners_.size(), 0);
78 }
79 
80 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0003_NeedRename, TestSize.Level1)
81 {
82     std::string type = "111";
83     std::string type2 = "222";
84     sptr<IPrintCallback> listener = nullptr;
85     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
86     userData->RegisterPrinterCallback(type, listener);
87     userData->UnregisterPrinterCallback(type2);
88     EXPECT_EQ(userData->registeredListeners_.size(), 1);
89 }
90 
91 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0004_NeedRename, TestSize.Level1)
92 {
93     std::string type = "111";
94     sptr<IPrintCallback> listener = nullptr;
95     PrinterInfo info;
96     int event = 0;
97     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
98     userData->RegisterPrinterCallback(type, listener);
99     userData->SendPrinterEvent(type, event, info);
100     EXPECT_EQ(userData->registeredListeners_.size(), 1);
101 }
102 
103 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0005_NeedRename, TestSize.Level1)
104 {
105     std::string type = "111";
106     std::string type2 = "222";
107     sptr<IPrintCallback> listener = nullptr;
108     PrinterInfo info;
109     int event = 0;
110     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
111     userData->RegisterPrinterCallback(type, listener);
112     userData->SendPrinterEvent(type2, event, info);
113     EXPECT_EQ(userData->registeredListeners_.size(), 1);
114 }
115 
116 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0006_NeedRename, TestSize.Level1)
117 {
118     std::string type = "111";
119     std::string type2 = "222";
120     sptr<IPrintCallback> listener = nullptr;
121     sptr<IPrintCallback> newListener = nullptr;
122     PrinterInfo info;
123     int event = 0;
124     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
125     userData->RegisterPrinterCallback(type, listener);
126     userData->RegisterPrinterCallback(type2, newListener);
127     userData->SendPrinterEvent(type, event, info);
128     EXPECT_EQ(userData->registeredListeners_.size(), 2);
129 }
130 
131 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0007_NeedRename, TestSize.Level1)
132 {
133     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
134     std::string jobId = "1";
135     PrintJob findPrintJob;
136     EXPECT_EQ(userData->QueryPrintJobById(jobId, findPrintJob), E_PRINT_INVALID_PRINTJOB);
137     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
138     userData->AddToPrintJobList(jobId, printJob);
139     EXPECT_EQ(userData->QueryPrintJobById(jobId, findPrintJob), E_PRINT_NONE);
140     jobId = "2";
141     EXPECT_EQ(userData->QueryPrintJobById(jobId, findPrintJob), E_PRINT_INVALID_PRINTJOB);
142 }
143 
144 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0008_NeedRename, TestSize.Level1)
145 {
146     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
147     std::string jobOrderId = "0";
148     std::string jobId = "1";
149     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
150     userData->AddToPrintJobList(jobId, printJob);
151     std::string newJobId = "2";
152     userData->UpdateQueuedJobList(newJobId, printJob, jobOrderId);
153     EXPECT_EQ(userData->queuedJobList_[newJobId], nullptr);
154     EXPECT_EQ(userData->jobOrderList_[jobOrderId], "");
155 }
156 
157 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0009_NeedRename, TestSize.Level1)
158 {
159     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
160     std::string jobOrderId = "0";
161     std::string jobId = "1";
162     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
163     userData->AddToPrintJobList(jobId, printJob);
164     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
165     std::vector<PrintJob> printJobs;
166     EXPECT_EQ(userData->QueryAllActivePrintJob(printJobs), E_PRINT_NONE);
167     printJob = nullptr;
168     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
169 }
170 
171 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0010_NeedRename, TestSize.Level1)
172 {
173     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
174     std::string type = "111";
175     sptr<IPrintCallback> listener = new (std::nothrow) DummyPrintCallbackStub();
176     PrinterInfo info;
177     int event = 0;
178     userData->RegisterPrinterCallback(type, listener);
179     userData->SendPrinterEvent(type, event, info);
180     EXPECT_EQ(userData->registeredListeners_.size(), 1);
181 }
182 
183 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0011_NeedRename, TestSize.Level1)
184 {
185     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
186     std::string jobOrderId = "0";
187     std::string jobId = "1";
188     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
189     userData->AddToPrintJobList(jobId, printJob);
190     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
191     EXPECT_EQ(userData->queuedJobList_[jobId], printJob);
192     EXPECT_EQ(userData->jobOrderList_[jobOrderId], jobId);
193     userData->AddToPrintJobList(jobId, printJob);
194     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
195     EXPECT_EQ(userData->queuedJobList_[jobId], printJob);
196     EXPECT_EQ(userData->jobOrderList_[jobOrderId], jobId);
197 }
198 
199 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0012_NeedRename, TestSize.Level1)
200 {
201     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
202     std::string jobOrderId = "0";
203     std::string jobId = "1";
204     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
205     userData->jobOrderList_.insert(std::make_pair(jobOrderId, jobId));
206     std::vector<PrintJob> printJobs;
207     EXPECT_EQ(userData->QueryAllActivePrintJob(printJobs), E_PRINT_NONE);
208 }
209 
210 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0013_NeedRename, TestSize.Level1)
211 {
212     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
213     int32_t userId = 101;
214     userData->SetUserId(userId);
215     EXPECT_EQ(userData->userId_, userId);
216 }
217 
218 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0014_NeedRename, TestSize.Level1)
219 {
220     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
221     std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-0105";
222     userData->SetLastUsedPrinter(printerId);
223     std::string printerId2 = "";
224     userData->SetLastUsedPrinter(printerId2);
225     EXPECT_EQ(userData->lastUsedPrinterId_, printerId);
226 }
227 
228 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0015_NeedRename, TestSize.Level1)
229 {
230     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
231     EXPECT_EQ(userData->GetDefaultPrinter(), "");
232 }
233 
234 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0016_NeedRename, TestSize.Level1)
235 {
236     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
237     EXPECT_EQ(userData->ParseUserData(), true);
238 }
239 
240 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0017_NeedRename, TestSize.Level1)
241 {
242     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
243     std::string fileData = "";
244     EXPECT_EQ(userData->GetFileData(fileData), true);
245 }
246 
247 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0018_NeedRename, TestSize.Level1)
248 {
249     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
250     EXPECT_EQ(userData->SetUserDataToFile(), true);
251 }
252 
253 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0019_NeedRename, TestSize.Level1)
254 {
255     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
256     EXPECT_EQ(userData->GetLastUsedPrinter(), "");
257 }
258 
259 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0020_NeedRename, TestSize.Level1)
260 {
261     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
262     std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-0105";
263     userData->SetDefaultPrinter(printerId, 0);
264     std::string printerId2 = "";
265     auto ret = userData->SetDefaultPrinter(printerId2, 0);
266     EXPECT_EQ(ret, E_PRINT_NONE);
267 }
268 
269 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0021_NeedRename, TestSize.Level1)
270 {
271     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
272     Json::Value jsonObject;
273     userData->ParseUserDataFromJson(jsonObject);
274     Json::Value userDataList;
275     jsonObject["print_user_data"] = userDataList;
276     userData->ParseUserDataFromJson(jsonObject);
277 
278     Json::Value jsonObject2;
279     Json::Value userDataList2;
280     userData->userId_ = 100;
281     Json::Value userData2;
282     userDataList2["100"] = userData2;
283     jsonObject2["print_user_data"] = userDataList2;
284     userData->ParseUserDataFromJson(jsonObject2);
285 
286     Json::Value jsonObject3;
287     Json::Value userDataList3;
288     Json::Value userData3;
289     userDataList3["100"] = userData3;
290     jsonObject3["print_user_data"] = userDataList3;
291     userData->ParseUserDataFromJson(jsonObject3);
292     EXPECT_EQ(userData->useLastUsedPrinterForDefault_, true);
293 }
294 
295 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0022_NeedRename, TestSize.Level1)
296 {
297     auto printUserData = std::make_shared<OHOS::Print::PrintUserData>();
298     Json::Value jsonObject;
299     Json::Value userDataList;
300     printUserData->userId_ = 100;
301     Json::Value userData;
302     userData["defaultPrinter"] = 123;
303     userDataList["100"] = userData;
304     jsonObject["print_user_data"] = userDataList;
305     printUserData->ParseUserDataFromJson(jsonObject);
306 
307     Json::Value jsonObject2;
308     Json::Value userDataList2;
309     Json::Value userData2;
310     userData2["defaultPrinter"] = "123";
311     userDataList2["100"] = userData2;
312     jsonObject2["print_user_data"] = userDataList2;
313     printUserData->ParseUserDataFromJson(jsonObject2);
314 
315     Json::Value jsonObject3;
316     Json::Value userDataList3;
317     Json::Value userData3;
318     userData3["defaultPrinter"] = "123";
319     userData3["lastUsedPrinter"] = 123;
320     userDataList3["100"] = userData3;
321     jsonObject3["print_user_data"] = userDataList3;
322     printUserData->ParseUserDataFromJson(jsonObject3);
323 
324     Json::Value jsonObject4;
325     Json::Value userDataList4;
326     Json::Value userData4;
327     userData4["defaultPrinter"] = "123";
328     userData4["lastUsedPrinter"] = "123";
329     userDataList4["100"] = userData4;
330     jsonObject4["print_user_data"] = userDataList4;
331     printUserData->ParseUserDataFromJson(jsonObject4);
332     EXPECT_EQ(printUserData->lastUsedPrinterId_, "123");
333 }
334 
335 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0023_NeedRename, TestSize.Level1)
336 {
337     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
338     Json::Value jsonObject;
339     std::string fileData0 = "test";
340     EXPECT_EQ(userData->CheckFileData(fileData0, jsonObject), false);
341 
342     Json::Value fileJson;
343     fileJson["key"] = "value";
344     std::string fileData = PrintJsonUtil::WriteString(fileJson);
345     EXPECT_EQ(userData->CheckFileData(fileData, jsonObject), false);
346 
347     Json::Value fileJson2;
348     fileJson2["version"] = 123;
349     std::string fileData2 = PrintJsonUtil::WriteString(fileJson2);
350     EXPECT_EQ(userData->CheckFileData(fileData2, jsonObject), false);
351 
352     Json::Value fileJson3;
353     fileJson3["version"] = "123";
354     std::string fileData3 = PrintJsonUtil::WriteString(fileJson3);
355     EXPECT_EQ(userData->CheckFileData(fileData3, jsonObject), false);
356 
357     Json::Value fileJson4;
358     fileJson4["version"] = "v1";
359     std::string fileData4 = PrintJsonUtil::WriteString(fileJson4);
360     EXPECT_EQ(userData->CheckFileData(fileData4, jsonObject), false);
361 
362     Json::Value fileJson5;
363     fileJson5["version"] = "v1";
364     fileJson5["print_user_data"] = "100";
365     std::string fileData5 = PrintJsonUtil::WriteString(fileJson5);
366     EXPECT_EQ(userData->CheckFileData(fileData5, jsonObject), true);
367 }
368 
369 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0030_NeedRename, TestSize.Level1)
370 {
371     std::string printerId1 = "com.ohos.spooler:p2p://DIRECT_PixLab_V1-0105";
372     std::string printerId2 = "com.ohos.spooler:p2p://DIRECT_PixLab_V1-0106";
373     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
374     EXPECT_NE(userData, nullptr);
375     userData->SetLastUsedPrinter(printerId1);
376     EXPECT_STREQ(userData->GetLastUsedPrinter().c_str(), printerId1.c_str());
377     userData->SetDefaultPrinter(printerId2, DEFAULT_PRINTER_TYPE_LAST_USED_PRINTER);
378     EXPECT_EQ(userData->CheckIfUseLastUsedPrinterForDefault(), true);
379     userData->SetLastUsedPrinter(printerId2);
380     userData->SetDefaultPrinter(printerId1, DELETE_DEFAULT_PRINTER);
381     userData->DeletePrinter(printerId1);
382     userData->DeletePrinter(printerId2);
383     userData->SetDefaultPrinter(printerId2, DELETE_LAST_USED_PRINTER);
384 }
385 
386 HWTEST_F(PrintUserDataTest, QueryQueuedPrintJobById_WhenNonexistenceJob_ShouldInvalidJobError, TestSize.Level1)
387 {
388     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
389     std::string jobId = "123";
390     EXPECT_NE(userData, nullptr);
391     PrintJob getPrintJob;
392     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
393     EXPECT_EQ(userData->QueryQueuedPrintJobById(jobId, getPrintJob), E_PRINT_INVALID_PRINTJOB);
394     userData->queuedJobList_["testId"] = printJob;
395     EXPECT_EQ(userData->QueryQueuedPrintJobById(jobId, getPrintJob), E_PRINT_INVALID_PRINTJOB);
396 }
397 
398 HWTEST_F(PrintUserDataTest, QueryQueuedPrintJobById_WhenExistenceJob_ShouldNoneError, TestSize.Level1)
399 {
400     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
401     EXPECT_NE(userData, nullptr);
402     std::string jobId = "123";
403     PrintJob getPrintJob;
404     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
405     userData->queuedJobList_[jobId] = nullptr;
406     EXPECT_EQ(userData->QueryQueuedPrintJobById(jobId, getPrintJob), E_PRINT_INVALID_PRINTJOB);
407     userData->queuedJobList_[jobId] = printJob;
408     EXPECT_EQ(userData->QueryQueuedPrintJobById(jobId, getPrintJob), E_PRINT_NONE);
409 }
410 
411 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0031_NeedRename0, TestSize.Level1)
412 {
413     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
414     std::vector<std::string> printerIds;
415     std::string jobOrderId = "0";
416     std::string printerId = "1";
417     std::string jobId = "123";
418     printerIds.push_back(printerId);
419     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
420     userData->AddToPrintJobList(jobId, printJob);
421     userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
422     std::vector<PrintJob> printJobs;
423     EXPECT_EQ(userData->QueryAllPrintJob(printerIds, printJobs), E_PRINT_NONE);
424 }
425 
426 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0031_NeedRename1, TestSize.Level1)
427 {
428     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
429     std::vector<std::string> printerIds;
430     std::string jobOrderId = "0";
431     std::string printerId = "1";
432     std::string jobId = "123";
433     printerIds.push_back(printerId);
434     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
435     userData->jobOrderList_.insert(std::make_pair(jobOrderId, jobId));
436     std::vector<PrintJob> printJobs;
437     EXPECT_EQ(userData->QueryAllPrintJob(printerIds, printJobs), E_PRINT_NONE);
438 }
439 
440 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0031_NeedRename2, TestSize.Level1)
441 {
442     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
443     std::vector<std::string> printerIds;
444     std::vector<PrintJob> printJobs;
445     std::string printerId = "1";
446     std::string jobId = "123";
447     printerIds.push_back(printerId);
448     userData->InitPrintHistoryJobList(printerId);
449     userData->printHistoryJobList_[printerId]->insert(std::make_pair(jobId, nullptr));
450     EXPECT_EQ(userData->QueryAllPrintJob(printerIds, printJobs), E_PRINT_INVALID_PRINTJOB);
451     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
452     printJob->SetPrinterId(printerId);
453     printJob->SetJobId(jobId);
454     userData->printHistoryJobList_[printerId]->erase(jobId);
455     userData->printHistoryJobList_[printerId]->insert(std::make_pair(jobId, printJob));
456     EXPECT_EQ(userData->QueryAllPrintJob(printerIds, printJobs), E_PRINT_NONE);
457 }
458 
459 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0032_NeedRename, TestSize.Level1)
460 {
461     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
462     std::string jobId = "0";
463     std::string printerId = "1";
464     PrintJob printJob;
465     userData->InitPrintHistoryJobList(printerId);
466     userData->printHistoryJobList_.insert(std::make_pair(printerId, nullptr));
467     EXPECT_EQ(userData->QueryHistoryPrintJobById(jobId, printJob), E_PRINT_INVALID_PRINTJOB);
468     userData->printHistoryJobList_.erase(printerId);
469     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>> printerHistoryJobList =
470         std::make_unique<std::map<std::string, std::shared_ptr<PrintJob>>>();
471     printerHistoryJobList->insert(std::make_pair(jobId, nullptr));
472     userData->printHistoryJobList_.insert(std::pair<std::string,
473     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>>>(printerId, std::move(printerHistoryJobList)));
474     EXPECT_EQ(userData->QueryHistoryPrintJobById(jobId, printJob), E_PRINT_INVALID_PRINTJOB);
475     std::shared_ptr<PrintJob> printJob1 = std::make_shared<PrintJob>();
476     printJob1->SetOption("{\"test\":\"test\"}");
477     printJob1->SetJobId(jobId);
478     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>> printerHistoryJobList1 =
479         std::make_unique<std::map<std::string, std::shared_ptr<PrintJob>>>();
480     printerHistoryJobList1->insert(std::pair<std::string, std::shared_ptr<PrintJob>>(jobId, printJob1));
481     userData->printHistoryJobList_.erase(printerId);
482     userData->printHistoryJobList_.insert(std::pair<std::string,
483     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>>>(printerId, std::move(printerHistoryJobList1)));
484     EXPECT_EQ(userData->QueryHistoryPrintJobById(jobId, printJob), E_PRINT_NONE);
485 }
486 
487 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0033_NeedRename, TestSize.Level1)
488 {
489     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
490     std::string printerId = "1";
491     std::string jobId = "1";
492     std::shared_ptr<PrintJob> printjob = std::make_shared<PrintJob>();
493     EXPECT_EQ(userData->AddPrintJobToHistoryList(printerId, jobId, printjob), false);
494     printjob = std::make_shared<PrintJob>();
495     printjob->SetOption("test");
496     EXPECT_EQ(userData->AddPrintJobToHistoryList(printerId, jobId, printjob), false);
497     printjob->SetOption("{\"test\":\"test\"}");
498     EXPECT_EQ(userData->AddPrintJobToHistoryList(printerId, jobId, printjob), true);
499     auto printerHistroyJobList = userData->printHistoryJobList_.find(printerId);
500     for (int32_t i = 2; i <= 501; i++) {
501         std::shared_ptr<PrintJob> printjob1 = std::make_shared<PrintJob>();
502         (printerHistroyJobList->second)->insert(std::make_pair(std::to_string(i), printjob1));
503     }
504     EXPECT_EQ(userData->AddPrintJobToHistoryList(printerId, jobId, printjob), true);
505 }
506 
507 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0034_NeedRename, TestSize.Level1)
508 {
509     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
510     std::string printerId = "1";
511     bool complete = true;
512     int32_t userId = 100;
513     userData->SetUserId(userId);
514     userData->FlushPrintHistoryJobFile(printerId);
515     EXPECT_EQ(complete, true);
516 }
517 
518 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0036_NeedRename, TestSize.Level1)
519 {
520     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
521     Json::Value jsonObject;
522     std::string filePath = "";
523     std::string printerId = "1";
524     EXPECT_EQ(userData->GetJsonObjectFromFile(jsonObject, filePath, printerId), false);
525 }
526 
527 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintHistory_NoJobInPrintHistoryJobList_ReturnFalse, TestSize.Level1)
528 {
529     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
530     Json::Value printerHistoryJson;
531     Json::Value printJobInfoJson;
532     std::string printerId = "1";
533     printerHistoryJson[printerId] = printJobInfoJson;
534     EXPECT_EQ(userData->ParseJsonObjectToPrintHistory(printerHistoryJson, printerId), false);
535 }
536 
537 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0038_NeedRename, TestSize.Level1)
538 {
539     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
540     std::string printerId = "123";
541     std::string jobId = "1";
542     std::shared_ptr<PrintJob> printjob = std::make_shared<PrintJob>();
543     EXPECT_EQ(userData->DeletePrintJobFromHistoryList(jobId), false);
544     userData->InitPrintHistoryJobList(printerId);
545     userData->AddPrintJobToHistoryList(printerId, jobId, printjob);
546     EXPECT_EQ(userData->DeletePrintJobFromHistoryList(jobId), false);
547 }
548 
549 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0039_NeedRename, TestSize.Level1)
550 {
551     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
552     std::string printerId = "1";
553     std::string jobId = "1";
554     std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
555     printJob->SetPrinterId(printerId);
556     printJob->SetJobId(jobId);
557     EXPECT_EQ(userData->DeletePrintJobFromHistoryListByPrinterId(printerId), true);
558     userData->AddPrintJobToHistoryList(printerId, jobId, printJob);
559     EXPECT_EQ(userData->DeletePrintJobFromHistoryListByPrinterId(jobId), true);
560 }
561 
562 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0040_NeedRename, TestSize.Level1)
563 {
564     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
565     std::string printerId = "1";
566     std::vector<std::string> printerIds = {printerId};
567     std::string jobId = "1";
568     std::shared_ptr<PrintJob> printjob = std::make_shared<PrintJob>();
569     EXPECT_EQ(userData->ContainsHistoryPrintJob(printerIds, jobId), false);
570     userData->AddPrintJobToHistoryList(printerId, jobId, printjob);
571     EXPECT_EQ(userData->ContainsHistoryPrintJob(printerIds, jobId), false);
572 }
573 
574 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0041_NeedRename, TestSize.Level1)
575 {
576     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
577     std::string printerId = "1";
578     bool complete = true;
579     userData->InitPrintHistoryJobList(printerId);
580     EXPECT_EQ(complete, true);
581 }
582 
583 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintHistory_NoPrinterInJson_ReturnFalse, TestSize.Level1)
584 {
585     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
586     Json::Value printerHistoryJson;
587     Json::Value printJobInfoJson;
588     std::string printerId = "testPrinterId";
589     std::string jobId = "testJobId";
590     std::shared_ptr<PrintJob> printjob = std::make_shared<PrintJob>();
591     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>> printerHistoryJobList1 =
592         std::make_unique<std::map<std::string, std::shared_ptr<PrintJob>>>();
593     printerHistoryJobList1->insert(std::pair<std::string, std::shared_ptr<PrintJob>>(jobId, printjob));
594     userData->printHistoryJobList_.insert(std::pair<std::string,
595     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>>>(printerId, std::move(printerHistoryJobList1)));
596     EXPECT_EQ(userData->ParseJsonObjectToPrintHistory(printerHistoryJson, printerId), false);
597 }
598 
599 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintHistory_WrongTypeOfJob_ReturnFalse, TestSize.Level1)
600 {
601     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
602     Json::Value printerHistoryJson;
603     std::string printerId = "testPrinterId";
604     std::string jobId = "testJobId";
605     std::shared_ptr<PrintJob> printjob = std::make_shared<PrintJob>();
606     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>> printerHistoryJobList1 =
607         std::make_unique<std::map<std::string, std::shared_ptr<PrintJob>>>();
608     printerHistoryJobList1->insert(std::pair<std::string, std::shared_ptr<PrintJob>>(jobId, printjob));
609     userData->printHistoryJobList_.insert(std::pair<std::string,
610     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>>>(printerId, std::move(printerHistoryJobList1)));
611     printerHistoryJson[printerId] = "testResult";
612     EXPECT_EQ(userData->ParseJsonObjectToPrintHistory(printerHistoryJson, printerId), false);
613 }
614 
615 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintHistory_JobIsNull_ReturnFalse, TestSize.Level1)
616 {
617     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
618     Json::Value printerHistoryJson;
619     Json::Value printJobInfoJson;
620     std::string printerId = "testPrinterId";
621     std::string jobId = "testJobId";
622     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>> printerHistoryJobList1 =
623         std::make_unique<std::map<std::string, std::shared_ptr<PrintJob>>>();
624     printerHistoryJobList1->insert(std::pair<std::string, std::shared_ptr<PrintJob>>(jobId, nullptr));
625     userData->printHistoryJobList_.insert(std::pair<std::string,
626     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>>>(printerId, std::move(printerHistoryJobList1)));
627     printerHistoryJson[printerId] = printJobInfoJson;
628     EXPECT_EQ(userData->ParseJsonObjectToPrintHistory(printerHistoryJson, printerId), false);
629 }
630 
631 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintHistory_JobNotNull_ReturnTrue, TestSize.Level1)
632 {
633     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
634     Json::Value printerHistoryJson;
635     Json::Value printJobInfoJson;
636     printJobInfoJson["jobId"] = "testJobId";
637     printJobInfoJson["printerId"] = "testPrinterId";
638     std::string printerId = "testPrinterId";
639     std::string jobId = "testJobId";
640     std::shared_ptr<PrintJob> printjob = std::make_shared<PrintJob>();
641     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>> printerHistoryJobList1 =
642         std::make_unique<std::map<std::string, std::shared_ptr<PrintJob>>>();
643     printerHistoryJobList1->insert(std::pair<std::string, std::shared_ptr<PrintJob>>(jobId, printjob));
644     userData->printHistoryJobList_.insert(std::pair<std::string,
645     std::unique_ptr<std::map<std::string, std::shared_ptr<PrintJob>>>>(printerId, std::move(printerHistoryJobList1)));
646     printerHistoryJson[printerId] = printJobInfoJson;
647     EXPECT_EQ(userData->ParseJsonObjectToPrintHistory(printerHistoryJson, printerId), true);
648 }
649 
650 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintJob_NoJobIdInJson_ReturnFalse, TestSize.Level1)
651 {
652     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
653     Json::Value printJobInfoJson;
654     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
655     EXPECT_EQ(userData->ParseJsonObjectToPrintJob(printJobInfoJson, printHistoryJob), false);
656 }
657 
658 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintJob_WrongTypeOfJobId_ReturnFalse, TestSize.Level1)
659 {
660     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
661     Json::Value printJobInfoJson;
662     printJobInfoJson["jobId"] = 123;
663     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
664     EXPECT_EQ(userData->ParseJsonObjectToPrintJob(printJobInfoJson, printHistoryJob), false);
665 }
666 
667 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintJob_NoPrinterIdInJson_ReturnFalse, TestSize.Level1)
668 {
669     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
670     Json::Value printJobInfoJson;
671     printJobInfoJson["jobId"] = "testJobId";
672     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
673     EXPECT_EQ(userData->ParseJsonObjectToPrintJob(printJobInfoJson, printHistoryJob), false);
674 }
675 
676 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintJob_WrongTypeOfPrinterId_ReturnFalse, TestSize.Level1)
677 {
678     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
679     Json::Value printJobInfoJson;
680     printJobInfoJson["jobId"] = "testJobId";
681     printJobInfoJson["printerId"] = 123;
682     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
683     EXPECT_EQ(userData->ParseJsonObjectToPrintJob(printJobInfoJson, printHistoryJob), false);
684 }
685 
686 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintJob_NoMemberInJson_GetJobStateReturnDefaultValue, TestSize.Level1)
687 {
688     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
689     Json::Value printJobInfoJson;
690     printJobInfoJson["jobId"] = "testJobId";
691     printJobInfoJson["printerId"] = "testPrinterId";
692     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
693     userData->ParseJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
694     EXPECT_EQ(printHistoryJob->GetJobState(), PRINT_JOB_PREPARED);
695 }
696 
697 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintJob_WrongValueType_GetJobStateReturnDefaultValue, TestSize.Level1)
698 {
699     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
700     Json::Value printJobInfoJson;
701     printJobInfoJson["jobId"] = "testJobId";
702     printJobInfoJson["printerId"] = "testPrinterId";
703     printJobInfoJson["jobState"] = "1";
704     printJobInfoJson["subState"] = "1";
705     printJobInfoJson["copyNumber"] = "1";
706     printJobInfoJson["isSequential"] = "1";
707     printJobInfoJson["isLandscape"] = "1";
708     printJobInfoJson["colorMode"] = "1";
709     printJobInfoJson["duplexMode"] = "1";
710     printJobInfoJson["pageRange"] = "1";
711     printJobInfoJson["pageSize"] = "1";
712     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
713     userData->ParseJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
714     EXPECT_EQ(printHistoryJob->GetJobState(), PRINT_JOB_PREPARED);
715 }
716 
717 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintJob_CorrectValue_GetJobStateCorrectly, TestSize.Level1)
718 {
719     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
720     Json::Value printJobInfoJson;
721     printJobInfoJson["jobId"] = "testJobId";
722     printJobInfoJson["printerId"] = "testPrinterId";
723     printJobInfoJson["jobState"] = 4;
724     printJobInfoJson["subState"] = 0;
725     printJobInfoJson["copyNumber"] = 1;
726     printJobInfoJson["isSequential"] = true;
727     printJobInfoJson["isLandscape"] = true;
728     printJobInfoJson["colorMode"] = 1;
729     printJobInfoJson["duplexMode"] = 1;
730     Json::Value pageRangeJson;
731     pageRangeJson["key"] = "value";
732     printJobInfoJson["pageRange"] = pageRangeJson;
733     Json::Value pageSizeJson;
734     pageSizeJson["key"] = "value";
735     printJobInfoJson["pageSize"] = pageSizeJson;
736     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
737     userData->ParseJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
738     EXPECT_EQ(printHistoryJob->GetJobState(), 4);
739 }
740 
741 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_NoMemberInJson_HasMarginReturnFalse, TestSize.Level1)
742 {
743     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
744     Json::Value printJobInfoJson;
745     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
746     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
747     EXPECT_EQ(printHistoryJob->HasMargin(), false);
748 }
749 
750 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_WrongValueType_HasMarginReturnFalse, TestSize.Level1)
751 {
752     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
753     Json::Value printJobInfoJson;
754     printJobInfoJson["hasmargin"] = "1";
755     printJobInfoJson["hasPreview"] = "1";
756     printJobInfoJson["hasOption"] = "1";
757     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
758     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
759     EXPECT_EQ(printHistoryJob->HasMargin(), false);
760 }
761 
762 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_HasmarginIsFalse_HasMarginReturnFalse, TestSize.Level1)
763 {
764     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
765     Json::Value printJobInfoJson;
766     printJobInfoJson["hasmargin"] = false;
767     printJobInfoJson["hasPreview"] = false;
768     printJobInfoJson["hasOption"] = false;
769     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
770     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
771     EXPECT_EQ(printHistoryJob->HasMargin(), false);
772 }
773 
774 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_NoMarginInJson_HasMarginReturnFalse, TestSize.Level1)
775 {
776     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
777     Json::Value printJobInfoJson;
778     printJobInfoJson["hasmargin"] = true;
779     printJobInfoJson["hasPreview"] = true;
780     printJobInfoJson["hasOption"] = true;
781     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
782     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
783     EXPECT_EQ(printHistoryJob->HasMargin(), false);
784 }
785 
786 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_WrongTypeOfMargin_HasMarginReturnFalse, TestSize.Level1)
787 {
788     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
789     Json::Value printJobInfoJson;
790     printJobInfoJson["hasmargin"] = true;
791     printJobInfoJson["margin"] = "1";
792     printJobInfoJson["hasPreview"] = true;
793     printJobInfoJson["preview"] = "1";
794     printJobInfoJson["hasOption"] = true;
795     printJobInfoJson["option"] = 1;
796     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
797     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
798     EXPECT_EQ(printHistoryJob->HasMargin(), false);
799 }
800 
801 HWTEST_F(PrintUserDataTest,
802     ParseOptionalJsonObjectToPrintJob_NoHasResultInPreview_HasMarginReturnFalse, TestSize.Level1)
803 {
804     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
805     Json::Value printJobInfoJson;
806     printJobInfoJson["hasmargin"] = true;
807     Json::Value marginJson;
808     marginJson["key"] = "value";
809     printJobInfoJson["margin"] = marginJson;
810     printJobInfoJson["hasPreview"] = true;
811     Json::Value previewJson;
812     previewJson["key"] = "value";
813     printJobInfoJson["preview"] = previewJson;
814     printJobInfoJson["hasOption"] = true;
815     printJobInfoJson["option"] = "1";
816     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
817     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
818     EXPECT_EQ(printHistoryJob->HasMargin(), true);
819 }
820 
821 HWTEST_F(PrintUserDataTest,
822     ParseOptionalJsonObjectToPrintJob_WrongTypeOfHasResult_HasResultReturnFalse, TestSize.Level1)
823 {
824     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
825     Json::Value printJobInfoJson;
826     printJobInfoJson["hasmargin"] = true;
827     Json::Value marginJson;
828     marginJson["key"] = "value";
829     printJobInfoJson["margin"] = marginJson;
830     printJobInfoJson["hasPreview"] = true;
831     Json::Value previewJson;
832     previewJson["hasResult_"] = "1";
833     previewJson["previewRange_"] = "1";
834     printJobInfoJson["preview"] = previewJson;
835     printJobInfoJson["hasOption"] = true;
836     printJobInfoJson["option"] = "1";
837     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
838     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
839     PrintPreviewAttribute previewAttr;
840     printHistoryJob->GetPreview(previewAttr);
841     EXPECT_EQ(previewAttr.HasResult(), false);
842 }
843 
844 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_HasResultIsFalse_HasResultReturnFalse, TestSize.Level1)
845 {
846     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
847     Json::Value printJobInfoJson;
848     printJobInfoJson["hasmargin"] = true;
849     Json::Value marginJson;
850     marginJson["key"] = "value";
851     printJobInfoJson["margin"] = marginJson;
852     printJobInfoJson["hasPreview"] = true;
853     Json::Value previewJson;
854     previewJson["hasResult_"] = false;
855     Json::Value previewRangeJson;
856     previewJson["previewRange_"] = previewRangeJson;
857     printJobInfoJson["preview"] = previewJson;
858     printJobInfoJson["hasOption"] = true;
859     printJobInfoJson["option"] = "1";
860     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
861     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
862     PrintPreviewAttribute previewAttr;
863     printHistoryJob->GetPreview(previewAttr);
864     EXPECT_EQ(previewAttr.HasResult(), false);
865 }
866 
867 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_NoResultInJson_HasResultReturnFalse, TestSize.Level1)
868 {
869     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
870     Json::Value printJobInfoJson;
871     printJobInfoJson["hasmargin"] = true;
872     Json::Value marginJson;
873     marginJson["key"] = "value";
874     printJobInfoJson["margin"] = marginJson;
875     printJobInfoJson["hasPreview"] = true;
876     Json::Value previewJson;
877     previewJson["hasResult_"] = true;
878     Json::Value previewRangeJson;
879     previewJson["previewRange_"] = previewRangeJson;
880     printJobInfoJson["preview"] = previewJson;
881     printJobInfoJson["hasOption"] = true;
882     printJobInfoJson["option"] = "1";
883     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
884     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
885     PrintPreviewAttribute previewAttr;
886     printHistoryJob->GetPreview(previewAttr);
887     EXPECT_EQ(previewAttr.HasResult(), false);
888 }
889 
890 HWTEST_F(PrintUserDataTest, ParseOptionalJsonObjectToPrintJob_WrongTypeOfResult_HasResultReturnFalse, TestSize.Level1)
891 {
892     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
893     Json::Value printJobInfoJson;
894     printJobInfoJson["hasmargin"] = true;
895     Json::Value marginJson;
896     marginJson["key"] = "value";
897     printJobInfoJson["margin"] = marginJson;
898     printJobInfoJson["hasPreview"] = true;
899     Json::Value previewJson;
900     previewJson["hasResult_"] = true;
901     previewJson["result_"] = "1";
902     Json::Value previewRangeJson;
903     previewJson["previewRange_"] = previewRangeJson;
904     printJobInfoJson["preview"] = previewJson;
905     printJobInfoJson["hasOption"] = true;
906     printJobInfoJson["option"] = "1";
907     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
908     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
909     PrintPreviewAttribute previewAttr;
910     printHistoryJob->GetPreview(previewAttr);
911     EXPECT_EQ(previewAttr.HasResult(), false);
912 }
913 
914 HWTEST_F(PrintUserDataTest,
915     ParseOptionalJsonObjectToPrintJob_CorrectValueOfResult_HasResultReturnTrue, TestSize.Level1)
916 {
917     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
918     Json::Value printJobInfoJson;
919     printJobInfoJson["hasmargin"] = true;
920     Json::Value marginJson;
921     marginJson["key"] = "value";
922     printJobInfoJson["margin"] = marginJson;
923     printJobInfoJson["hasPreview"] = true;
924     Json::Value previewJson;
925     previewJson["hasResult_"] = true;
926     previewJson["result_"] = 1;
927     Json::Value previewRangeJson;
928     previewRangeJson["key"] = "value";
929     previewJson["previewRange_"] = previewRangeJson;
930     printJobInfoJson["preview"] = previewJson;
931     printJobInfoJson["hasOption"] = true;
932     printJobInfoJson["option"] = "1";
933     std::shared_ptr<PrintJob> printHistoryJob = std::make_shared<PrintJob>();
934     userData->ParseOptionalJsonObjectToPrintJob(printJobInfoJson, printHistoryJob);
935     PrintPreviewAttribute previewAttr;
936     printHistoryJob->GetPreview(previewAttr);
937     EXPECT_EQ(previewAttr.HasResult(), true);
938 }
939 
940 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintPageSize_NullValue_GetEmptyId, TestSize.Level1)
941 {
942     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
943     Json::Value jsonObject;
944     PrintPageSize pageSize = userData->ParseJsonObjectToPrintPageSize(jsonObject);
945     EXPECT_EQ(pageSize.GetId(), "");
946 }
947 
948 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintPageSize_WrongValueType_GetEmptyId, TestSize.Level1)
949 {
950     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
951     Json::Value jsonObject;
952     jsonObject["id_"] = 1;
953     jsonObject["name_"] = 1;
954     jsonObject["width_"] = "1";
955     jsonObject["height_"] = "1";
956     PrintPageSize pageSize = userData->ParseJsonObjectToPrintPageSize(jsonObject);
957     EXPECT_EQ(pageSize.GetId(), "");
958 }
959 
960 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintPageSize_WrongType_GetEmptyId, TestSize.Level1)
961 {
962     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
963     Json::Value jsonObject;
964     jsonObject["id_"] = "1";
965     jsonObject["name_"] = "1";
966     jsonObject["width_"] = 1;
967     jsonObject["height_"] = 1;
968     PrintPageSize pageSize = userData->ParseJsonObjectToPrintPageSize(jsonObject);
969     EXPECT_EQ(pageSize.GetId(), "1");
970 }
971 
972 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintRange_NullValue_HasStartPageReturnFalse, TestSize.Level1)
973 {
974     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
975     Json::Value jsonObject;
976     PrintRange printRange = userData->ParseJsonObjectToPrintRange(jsonObject);
977     EXPECT_EQ(printRange.HasStartPage(), false);
978 }
979 
980 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintRange_WrongValueType_HasStartPageReturnFalse, TestSize.Level1)
981 {
982     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
983     Json::Value jsonObject;
984     jsonObject["hasStartPage_"] = "1";
985     jsonObject["hasEndPage_"] = "1";
986     jsonObject["pages"] = "1";
987     PrintRange printRange = userData->ParseJsonObjectToPrintRange(jsonObject);
988     EXPECT_EQ(printRange.HasStartPage(), false);
989 }
990 
991 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintRange_HasStartPageIsFalse_HasStartPageReturnFalse, TestSize.Level1)
992 {
993     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
994     Json::Value jsonObject;
995     jsonObject["hasStartPage_"] = false;
996     jsonObject["hasEndPage_"] = false;
997     Json::Value pagesJsonObject;
998     pagesJsonObject.append("1");
999     pagesJsonObject.append(1);
1000     jsonObject["pages"] = pagesJsonObject;
1001     PrintRange printRange = userData->ParseJsonObjectToPrintRange(jsonObject);
1002     EXPECT_EQ(printRange.HasStartPage(), false);
1003 }
1004 
1005 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintRange_NoStartPage_HasStartPageReturnFalse, TestSize.Level1)
1006 {
1007     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1008     Json::Value jsonObject;
1009     jsonObject["hasStartPage_"] = true;
1010     jsonObject["hasEndPage_"] = true;
1011     PrintRange printRange = userData->ParseJsonObjectToPrintRange(jsonObject);
1012     EXPECT_EQ(printRange.HasStartPage(), false);
1013 }
1014 
1015 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintRange_WrongTyprOfStartPage_HasStartPageReturnFalse, TestSize.Level1)
1016 {
1017     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1018     Json::Value jsonObject;
1019     jsonObject["hasStartPage_"] = true;
1020     jsonObject["startPage"] = "1";
1021     jsonObject["hasEndPage_"] = true;
1022     jsonObject["endPage"] = "2";
1023     PrintRange printRange = userData->ParseJsonObjectToPrintRange(jsonObject);
1024     EXPECT_EQ(printRange.HasStartPage(), false);
1025 }
1026 
1027 HWTEST_F(PrintUserDataTest, ParseJsonObjectToPrintRange_CorrectValue_HasStartPageReturnTrue, TestSize.Level1)
1028 {
1029     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1030     Json::Value jsonObject;
1031     jsonObject["hasStartPage_"] = true;
1032     jsonObject["startPage"] = 1;
1033     jsonObject["hasEndPage_"] = true;
1034     jsonObject["endPage"] = 2;
1035     PrintRange printRange = userData->ParseJsonObjectToPrintRange(jsonObject);
1036     EXPECT_EQ(printRange.HasStartPage(), true);
1037 }
1038 
1039 HWTEST_F(PrintUserDataTest, ParseJsonObjectToMargin_NullValue_HasTopReturnFalse, TestSize.Level1)
1040 {
1041     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1042     Json::Value jsonObject;
1043     PrintMargin margin = userData->ParseJsonObjectToMargin(jsonObject);
1044     EXPECT_EQ(margin.HasTop(), false);
1045 }
1046 
1047 HWTEST_F(PrintUserDataTest, ParseJsonObjectToMargin_WrongValueType_HasTopReturnFalse, TestSize.Level1)
1048 {
1049     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1050     Json::Value jsonObject;
1051     jsonObject["hasTop_"] = "1";
1052     jsonObject["hasLeft_"] = "1";
1053     jsonObject["hasRight_"] = "1";
1054     jsonObject["hasBottom_"] = "1";
1055     PrintMargin margin = userData->ParseJsonObjectToMargin(jsonObject);
1056     EXPECT_EQ(margin.HasTop(), false);
1057 }
1058 
1059 HWTEST_F(PrintUserDataTest, ParseJsonObjectToMargin_HasTopIsFalse_HasTopReturnFalse, TestSize.Level1)
1060 {
1061     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1062     Json::Value jsonObject;
1063     jsonObject["hasTop_"] = false;
1064     jsonObject["hasLeft_"] = false;
1065     jsonObject["hasRight_"] = false;
1066     jsonObject["hasBottom_"] = false;
1067     PrintMargin margin = userData->ParseJsonObjectToMargin(jsonObject);
1068     EXPECT_EQ(margin.HasTop(), false);
1069 }
1070 
1071 HWTEST_F(PrintUserDataTest, ParseJsonObjectToMargin_NoTop_HasTopReturnFalse, TestSize.Level1)
1072 {
1073     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1074     Json::Value jsonObject;
1075     jsonObject["hasTop_"] = true;
1076     jsonObject["hasLeft_"] = true;
1077     jsonObject["hasRight_"] = true;
1078     jsonObject["hasBottom_"] = true;
1079     PrintMargin margin = userData->ParseJsonObjectToMargin(jsonObject);
1080     EXPECT_EQ(margin.HasTop(), false);
1081 }
1082 
1083 HWTEST_F(PrintUserDataTest, ParseJsonObjectToMargin_WrongTypeOfTop_HasTopReturnFalse, TestSize.Level1)
1084 {
1085     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1086     Json::Value jsonObject;
1087     jsonObject["hasTop_"] = true;
1088     jsonObject["top_"] = "1";
1089     jsonObject["hasLeft_"] = true;
1090     jsonObject["left_"] = "1";
1091     jsonObject["hasRight_"] = true;
1092     jsonObject["right_"] = "1";
1093     jsonObject["hasBottom_"] = true;
1094     jsonObject["bottom_"] = "1";
1095     PrintMargin margin = userData->ParseJsonObjectToMargin(jsonObject);
1096     EXPECT_EQ(margin.HasTop(), false);
1097 }
1098 
1099 HWTEST_F(PrintUserDataTest, ParseJsonObjectToMargin_CorrectValue_HasTopReturnTrue, TestSize.Level1)
1100 {
1101     auto userData = std::make_shared<OHOS::Print::PrintUserData>();
1102     Json::Value jsonObject;
1103     jsonObject["hasTop_"] = true;
1104     jsonObject["top_"] = 1;
1105     jsonObject["hasLeft_"] = true;
1106     jsonObject["left_"] = 1;
1107     jsonObject["hasRight_"] = true;
1108     jsonObject["right_"] = 1;
1109     jsonObject["hasBottom_"] = true;
1110     jsonObject["bottom_"] = 1;
1111     PrintMargin margin = userData->ParseJsonObjectToMargin(jsonObject);
1112     EXPECT_EQ(margin.HasTop(), true);
1113 }
1114 }
1115 }