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, 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, 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, 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, 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, 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, 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, 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, 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, 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->QueryAllPrintJob(printJobs), E_PRINT_NONE);
167 printJob = nullptr;
168 userData->UpdateQueuedJobList(jobId, printJob, jobOrderId);
169 }
170
171 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0010, 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, 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, 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->QueryAllPrintJob(printJobs), E_PRINT_NONE);
208 }
209
210 HWTEST_F(PrintUserDataTest, PrintUserDataTest_0013, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 }