1 /*
2 * Copyright (c) 2023 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 <thread>
17 #include <gtest/gtest.h>
18 #define private public
19 #include "print_cups_client.h"
20 #undef private
21 #include "print_constant.h"
22 #include "print_log.h"
23 #include "fstream"
24 #include "print_json_util.h"
25 #define private public
26 #include "print_service_ability.h"
27 #undef private
28
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Print {
33 static constexpr const char *JOB_OPTIONS =
34 "{\"jobName\":\"xx\",\"jobNum\":1,\"mediaType\":\"stationery\",\"documentCategory\":0,\"printQuality\":\"4\","
35 "\"printerName\":\"printer1\",\"printerUri\":\"ipp://192.168.0.1:111/ipp/print\",\"borderless\":true,"
36 "\"documentFormat\":\"application/pdf\",\"files\":[\"/data/1.pdf\"],\"isAutoRotate\":true}";
37
38 const uint32_t DIR_MODE = 0771;
39 const int32_t STATE_UPDATE_STEP = 5;
40 const int TEST_CUPS_JOB_ID = 100;
41
42 static const std::string PRINTER_STATE_NONE = "none";
43 static const std::string PRINTER_STATE_MEDIA_EMPTY = "media-empty";
44 static const std::string PRINTER_STATE_MEDIA_JAM = "media-jam";
45 static const std::string PRINTER_STATE_PAUSED = "paused";
46 static const std::string PRINTER_STATE_TONER_LOW = "toner-low";
47 static const std::string PRINTER_STATE_TONER_EMPTY = "toner-empty";
48 static const std::string PRINTER_STATE_DOOR_EMPTY = "door-open";
49 static const std::string PRINTER_STATE_MEDIA_NEEDED = "media-needed";
50 static const std::string PRINTER_STATE_MARKER_LOW = "marker-supply-low";
51 static const std::string PRINTER_STATE_MARKER_EMPTY = "marker-supply-empty";
52 static const std::string PRINTER_STATE_INK_EMPTY = "marker-ink-almost-empty";
53 static const std::string PRINTER_STATE_COVER_OPEN = "cover-open";
54 static const std::string PRINTER_STATE_OFFLINE = "offline";
55 static const std::string DEFAULT_MAKE_MODEL = "IPP Everywhere";
56 static const std::string REMOTE_PRINTER_MAKE_MODEL = "Remote Printer";
57 static const std::string BSUNI_PPD_NAME = "Brocadesoft Universal Driver";
58
59 static const std::string TEST_SERVICE_JOB_ID = "test_id";
60 static const std::string PRINTER_URI = "test_printer_uri";
61 static const std::string PRINTER_PRINTER_NAME = "test_printer_name";
62 static const std::string PRINTER_PRINTER_ID = "test_printer_id";
63
64 class PrintCupsClientTest : public testing::Test {
65 public:
66 static void SetUpTestCase(void);
67 static void TearDownTestCase(void);
68 void SetUp();
69 void TearDown();
70 std::string GetDefaultJobId();
71 };
72
SetUpTestCase(void)73 void PrintCupsClientTest::SetUpTestCase(void)
74 {}
75
TearDownTestCase(void)76 void PrintCupsClientTest::TearDownTestCase(void)
77 {}
78
SetUp(void)79 void PrintCupsClientTest::SetUp(void)
80 {
81 static int32_t testNo = 0;
82 PRINT_HILOGI("PrintCupsClientTest_%{public}d", ++testNo);
83 }
84
TearDown(void)85 void PrintCupsClientTest::TearDown(void)
86 {}
87
GetDefaultJobId()88 std::string PrintCupsClientTest::GetDefaultJobId()
89 {
90 return std::to_string(0);
91 }
92
93 /**
94 * @tc.name: PrintCupsClientTest_0001
95 * @tc.desc: StartCupsdService
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0001, TestSize.Level1)
100 {
101 OHOS::Print::PrintCupsClient printCupsClient;
102 int32_t ret = printCupsClient.StartCupsdService();
103 EXPECT_EQ(ret, E_PRINT_NONE);
104 }
105
106 /**
107 * @tc.name: PrintCupsClientTest_0002
108 * @tc.desc: ChangeFilterPermission
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0002, TestSize.Level1)
113 {
114 OHOS::Print::PrintCupsClient printCupsClient;
115 std::string path = "";
116 mode_t mode = 16;
117 EXPECT_EQ(printCupsClient.ChangeFilterPermission(path, mode), false);
118 }
119
120 /**
121 * @tc.name: PrintCupsClientTest_0003
122 * @tc.desc: SymlinkDirectory
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0003, TestSize.Level1)
127 {
128 OHOS::Print::PrintCupsClient printCupsClient;
129 const char *srcDir = "./PrintCupsClientTest_0003_srcDir";
130 const char *destDir = "./PrintCupsClientTest_0003_destDir";
131
132 if (access(srcDir, F_OK) != 0) {
133 mkdir(srcDir, DIR_MODE);
134 }
135 if (access(destDir, F_OK) != 0) {
136 mkdir (destDir, DIR_MODE);
137 }
138
139 std::string srcFilePath = "./PrintCupsClientTest_0003_srcDir/PrintCupsClientTestFileName";
140 std::ofstream testSrcFile(srcFilePath.c_str(), std::ios::out);
141 EXPECT_EQ(testSrcFile.is_open(), true);
142 testSrcFile.close();
143
144 printCupsClient.SymlinkDirectory(srcDir, destDir);
145
146 struct stat destDirstat = {};
147 EXPECT_EQ(lstat((std::string(destDir)
148 + "/PrintCupsClientTestFileName").c_str(), &destDirstat), 0);
149 EXPECT_EQ(S_ISLNK(destDirstat.st_mode), true);
150
151 EXPECT_GE(std::filesystem::remove_all(std::filesystem::current_path() / srcDir), 0);
152 EXPECT_GE(std::filesystem::remove_all(std::filesystem::current_path() / destDir), 0);
153 }
154
155 /**
156 * @tc.name: PrintCupsClientTest_0004
157 * @tc.desc: CopyDirectory
158 * @tc.type: FUNC
159 * @tc.require:
160 */
161 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0004, TestSize.Level1)
162 {
163 OHOS::Print::PrintCupsClient printCupsClient;
164 const char *srcDir = "./PrintCupsClientTest_0004_srcDir";
165 const char *destDir = "./PrintCupsClientTest_0004_destDir";
166 const char *subSrcDir = "PrintCupsClientTest_0004_srcDir/PrintCupsClientTest";
167
168 if (access(srcDir, F_OK) != 0) {
169 mkdir(srcDir, DIR_MODE);
170 }
171
172 if (access(destDir, F_OK) != 0) {
173 mkdir(destDir, DIR_MODE);
174 }
175
176 if (access(subSrcDir, F_OK) != 0) {
177 mkdir(subSrcDir, DIR_MODE);
178 }
179
180 std::string srcFilePath = std::string(subSrcDir) + "/PrintCupsClientTestFileName";
181 std::ofstream testSrcFile(srcFilePath.c_str(), std::ios::out);
182 EXPECT_EQ(testSrcFile.is_open(), true);
183 testSrcFile.close();
184
185 printCupsClient.CopyDirectory(srcDir, destDir);
186
187 EXPECT_EQ(std::filesystem::is_regular_file(
188 std::string(destDir) + "/PrintCupsClientTest/PrintCupsClientTestFileName"),
189 true);
190 EXPECT_GE(std::filesystem::remove_all(std::filesystem::current_path() / srcDir), 0);
191 EXPECT_GE(std::filesystem::remove_all(std::filesystem::current_path() / destDir), 0);
192 }
193
194 /**
195 * @tc.name: PrintCupsClientTest_0005
196 * @tc.desc: InitCupsResources
197 * @tc.type: FUNC
198 * @tc.require:
199 */
200 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0005, TestSize.Level1)
201 {
202 OHOS::Print::PrintCupsClient printCupsClient;
203 int32_t ret = printCupsClient.InitCupsResources();
204 EXPECT_EQ(ret, E_PRINT_NONE);
205 }
206
207 /**
208 * @tc.name: PrintCupsClientTest_0006
209 * @tc.desc: StopCupsdService
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0006, TestSize.Level1)
214 {
215 OHOS::Print::PrintCupsClient printCupsClient;
216 int32_t ret = printCupsClient.StartCupsdService();
217 EXPECT_EQ(ret, E_PRINT_NONE);
218 printCupsClient.StopCupsdService();
219 }
220
221 /**
222 * @tc.name: PrintCupsClientTest_0008
223 * @tc.desc: SetDefaultPrinter
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0008, TestSize.Level1)
228 {
229 OHOS::Print::PrintCupsClient printCupsClient;
230 std::string printerName = "DIRECT-PixLab_V1-0105";
231 printCupsClient.SetDefaultPrinter(printerName);
232 EXPECT_EQ(printCupsClient.StartCupsdService(), E_PRINT_NONE);
233 printCupsClient.SetDefaultPrinter(printerName);
234 }
235
236 /**
237 * @tc.name: PrintCupsClientTest_0009
238 * @tc.desc: QueryPrinterInfoByPrinterId
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0009, TestSize.Level1)
243 {
244 OHOS::Print::PrintCupsClient printCupsClient;
245 std::string printerName = "DIRECT-PixLab_V1-0105";
246 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-0105";
247 PrinterInfo info;
248 info.SetPrinterName(printerName);
249 EXPECT_EQ(printCupsClient.QueryPrinterInfoByPrinterId(printerId, info), E_PRINT_SERVER_FAILURE);
250 }
251
252 /**
253 * @tc.name: PrintCupsClientTest_0012
254 * @tc.desc: QueryPrinterCapabilityByUri
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0012, TestSize.Level1)
259 {
260 OHOS::Print::PrintCupsClient printCupsClient;
261 std::string printerUri = "ipp://192.168.186.1:631/ipp/print";
262 std::string printerId = "1";
263 PrinterCapability printerCaps;
264 int32_t ret = printCupsClient.QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
265 EXPECT_EQ(ret, E_PRINT_SERVER_FAILURE);
266 }
267
268 /**
269 * @tc.name: PrintCupsClientTest_0013
270 * @tc.desc: AddCupsPrintJob
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0013, TestSize.Level1)
275 {
276 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
277 PrintJob testJob;
278 printCupsClient->AddCupsPrintJob(testJob);
279 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
280 }
281
282 /**
283 * @tc.name: PrintCupsClientTest_0014
284 * @tc.desc: AddCupsPrintJob
285 * @tc.type: FUNC
286 * @tc.require:
287 */
288 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0014, TestSize.Level1)
289 {
290 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
291 PrintJob testJob;
292 testJob.SetJobId(GetDefaultJobId());
293 std::vector<uint32_t> files = {1};
294 testJob.SetFdList(files);
295 testJob.SetColorMode(1);
296 testJob.SetCopyNumber(1);
297 testJob.SetDuplexMode(0);
298 OHOS::Print::PrintPageSize pageSize;
299 pageSize.SetId("pgid-1234");
300 testJob.SetPageSize(pageSize);
301 testJob.SetPrinterId("printid-1234");
302 testJob.SetOption(JOB_OPTIONS);
303 printCupsClient->AddCupsPrintJob(testJob);
304 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
305 }
306
307 /**
308 * @tc.name: PrintCupsClientTest_0015
309 * @tc.desc: StartNextJob
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0015, TestSize.Level1)
314 {
315 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
316 printCupsClient->toCups_ = false;
317 printCupsClient->StartNextJob();
318 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
319 }
320
321 /**
322 * @tc.name: PrintCupsClientTest_0016
323 * @tc.desc: StartNextJob
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0016, TestSize.Level1)
328 {
329 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
330 PrintJob testJob;
331 testJob.SetJobId(GetDefaultJobId());
332 std::vector<uint32_t> files = {1};
333 testJob.SetFdList(files);
334 OHOS::Print::PrintPageSize pageSize;
335 pageSize.SetId("pgid-1234");
336 testJob.SetPageSize(pageSize);
337 testJob.SetPrinterId("printid-1234");
338 testJob.SetOption(JOB_OPTIONS);
339 JobParameters *jobParams = printCupsClient->BuildJobParameters(testJob);
340 printCupsClient->jobQueue_.push_back(jobParams);
341 printCupsClient->toCups_ = false;
342 printCupsClient->StartNextJob();
343 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
344 }
345
346 /**
347 * @tc.name: PrintCupsClientTest_0018
348 * @tc.desc: StartNextJob
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0018, TestSize.Level1)
353 {
354 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
355 JobParameters *jobParams = nullptr;
356 printCupsClient->jobQueue_.push_back(jobParams);
357 printCupsClient->toCups_ = false;
358 printCupsClient->StartNextJob();
359 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
360 }
361
362 /**
363 * @tc.name: PrintCupsClientTest_0019
364 * @tc.desc: JobCompleteCallback
365 * @tc.type: FUNC
366 * @tc.require:
367 */
368 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0019, TestSize.Level1)
369 {
370 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
371 PrintJob testJob;
372 testJob.SetJobId(GetDefaultJobId());
373 std::vector<uint32_t> files = {1};
374 testJob.SetFdList(files);
375 OHOS::Print::PrintPageSize pageSize;
376 pageSize.SetId("pgid-1234");
377 testJob.SetPageSize(pageSize);
378 testJob.SetPrinterId("printid-1234");
379 testJob.SetOption(JOB_OPTIONS);
380 JobParameters *jobParams = printCupsClient->BuildJobParameters(testJob);
381 printCupsClient->JobSentCallback(); // currentJob_ is null, do nothing
382 printCupsClient->currentJob_ = jobParams;
383 printCupsClient->JobSentCallback(); // clear currentJob_
384 EXPECT_EQ(printCupsClient->currentJob_, nullptr);
385 std::this_thread::sleep_for(std::chrono::milliseconds(2000));
386 }
387
388 /**
389 * @tc.name: PrintCupsClientTest_0020
390 * @tc.desc: FillBorderlessOptions
391 * @tc.type: FUNC
392 * @tc.require:
393 */
394 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0020, TestSize.Level1)
395 {
396 OHOS::Print::PrintCupsClient printCupsClient;
397 int numOptions = 0;
398 cups_option_t *options = nullptr;
399 EXPECT_EQ(printCupsClient.FillBorderlessOptions(nullptr, numOptions, &options), 0);
400 EXPECT_EQ(printCupsClient.FillJobOptions(nullptr, numOptions, &options), 0);
401 }
402 /**
403 * @tc.name: PrintCupsClientTest_0021
404 * @tc.desc: FillBorderlessOptions
405 * @tc.type: FUNC
406 * @tc.require:
407 */
408 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0021, TestSize.Level1)
409 {
410 OHOS::Print::PrintCupsClient printCupsClient;
411 PrintJob testJob;
412 testJob.SetJobId(GetDefaultJobId());
413 std::vector<uint32_t> files = {1};
414 testJob.SetFdList(files);
415 OHOS::Print::PrintPageSize pageSize;
416 pageSize.SetId("pgid-1234");
417 testJob.SetPageSize(pageSize);
418 testJob.SetPrinterId("printid-1234");
419 testJob.SetOption(JOB_OPTIONS);
420 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
421 jobParams->borderless = 1;
422 jobParams->mediaSize = "";
423 jobParams->mediaType = "";
424 int numOptions = 0;
425 cups_option_t *options = nullptr;
426 printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options);
427 EXPECT_EQ(numOptions, 0);
428 delete jobParams;
429 delete options;
430 }
431
432 /**
433 * @tc.name: PrintCupsClientTest_0022
434 * @tc.desc: FillBorderlessOptions
435 * @tc.type: FUNC
436 * @tc.require:
437 */
438 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0022, TestSize.Level1)
439 {
440 OHOS::Print::PrintCupsClient printCupsClient;
441 PrintJob testJob;
442 testJob.SetJobId(GetDefaultJobId());
443 std::vector<uint32_t> files = {1};
444 testJob.SetFdList(files);
445 OHOS::Print::PrintPageSize pageSize;
446 pageSize.SetId("pgid-1234");
447 testJob.SetPageSize(pageSize);
448 testJob.SetPrinterId("printid-1234");
449 testJob.SetOption(JOB_OPTIONS);
450 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
451 jobParams->mediaSize = "testMediaSize";
452 jobParams->mediaType = "testMediaType";
453 int numOptions = 0;
454 cups_option_t *options = nullptr;
455 printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options);
456 EXPECT_EQ(numOptions, 0);
457 delete jobParams;
458 delete options;
459 }
460
461 /**
462 * @tc.name: PrintCupsClientTest_0023
463 * @tc.desc: FillBorderlessOptions
464 * @tc.type: FUNC
465 * @tc.require:
466 */
467 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0023, TestSize.Level1)
468 {
469 OHOS::Print::PrintCupsClient printCupsClient;
470 PrintJob testJob;
471 testJob.SetJobId(GetDefaultJobId());
472 std::vector<uint32_t> files = {1};
473 testJob.SetFdList(files);
474 OHOS::Print::PrintPageSize pageSize;
475 pageSize.SetId("pgid-1234");
476 testJob.SetPageSize(pageSize);
477 testJob.SetPrinterId("printid-1234");
478 testJob.SetOption(JOB_OPTIONS);
479 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
480 jobParams->borderless = 0;
481 jobParams->mediaType = CUPS_MEDIA_TYPE_PHOTO_GLOSSY;
482 int numOptions = 0;
483 cups_option_t *options = nullptr;
484 int ret = printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options);
485 EXPECT_EQ(ret, 3);
486 delete jobParams;
487 delete options;
488 }
489
490 /**
491 * @tc.name: PrintCupsClientTest_0024
492 * @tc.desc: FillBorderlessOptions
493 * @tc.type: FUNC
494 * @tc.require:
495 */
496 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0024, TestSize.Level1)
497 {
498 OHOS::Print::PrintCupsClient printCupsClient;
499 PrintJob testJob;
500 testJob.SetJobId(GetDefaultJobId());
501 std::vector<uint32_t> files = {1};
502 testJob.SetFdList(files);
503 OHOS::Print::PrintPageSize pageSize;
504 pageSize.SetId("pgid-1234");
505 testJob.SetPageSize(pageSize);
506 testJob.SetPrinterId("printid-1234");
507 testJob.SetOption(JOB_OPTIONS);
508 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
509 jobParams->borderless = 1;
510 jobParams->mediaType = CUPS_MEDIA_TYPE_PHOTO_GLOSSY;
511 jobParams->mediaSize = CUPS_MEDIA_4X6;
512 int numOptions = 0;
513 cups_option_t *options = nullptr;
514 int ret = printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options);
515 EXPECT_EQ(ret, 2);
516 delete jobParams;
517 delete options;
518 }
519
520 /**
521 * @tc.name: PrintCupsClientTest_0025
522 * @tc.desc: FillJobOptions
523 * @tc.type: FUNC
524 * @tc.require:
525 */
526 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0025, TestSize.Level1)
527 {
528 int num = 0;
529 cups_option_t *options = nullptr;
530 OHOS::Print::PrintCupsClient printCupsClient;
531 PrintJob jobInfo;
532 jobInfo.SetCopyNumber(2);
533 jobInfo.SetDuplexMode(1);
534 jobInfo.SetColorMode(0);
535 jobInfo.SetOption(JOB_OPTIONS);
536 JobParameters *jobParams = printCupsClient.BuildJobParameters(jobInfo);
537 jobParams->printerId = "1";
538 jobParams->numCopies = 2;
539 jobParams->duplex = "";
540 jobParams->printQuality = "";
541 jobParams->color = "";
542 jobParams->isAutoRotate = true;
543 int ret = printCupsClient.FillJobOptions(jobParams, num, &options);
544 EXPECT_EQ(ret, 8);
545 delete jobParams;
546 delete options;
547 }
548
549 /**
550 * @tc.name: PrintCupsClientTest_0026
551 * @tc.desc: FillJobOptions
552 * @tc.type: FUNC
553 * @tc.require:
554 */
555 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0026, TestSize.Level1)
556 {
557 int num = 0;
558 cups_option_t *options = nullptr;
559 OHOS::Print::PrintCupsClient printCupsClient;
560 PrintJob jobInfo;
561 jobInfo.SetCopyNumber(2);
562 jobInfo.SetDuplexMode(1);
563 jobInfo.SetColorMode(0);
564 jobInfo.SetOption(JOB_OPTIONS);
565 JobParameters *jobParams = printCupsClient.BuildJobParameters(jobInfo);
566 jobParams->printerId = "1";
567 jobParams->numCopies = 0;
568 jobParams->duplex = "test_duplex";
569 jobParams->printQuality = "test_printQuality";
570 jobParams->color = "test_color";
571 jobParams->borderless = 1;
572 jobParams->mediaType = CUPS_MEDIA_TYPE_PHOTO_GLOSSY;
573 jobParams->mediaSize = CUPS_MEDIA_4X6;
574 int ret = printCupsClient.FillJobOptions(jobParams, num, &options);
575 EXPECT_EQ(ret, 7);
576 delete jobParams;
577 delete options;
578 }
579
580 /**
581 * @tc.name: PrintCupsClientTest_0027
582 * @tc.desc: QueryAddedPrinterList
583 * @tc.type: FUNC
584 * @tc.require:
585 */
586 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0027, TestSize.Level1)
587 {
588 OHOS::Print::PrintCupsClient printCupsClient;
589 std::vector<std::string> printerNameList;
590 printerNameList.push_back("testPrinterName");
591 printCupsClient.StopCupsdService();
592 EXPECT_EQ(printCupsClient.QueryAddedPrinterList(printerNameList), E_PRINT_NONE);
593 }
594
595 /**
596 * @tc.name: PrintCupsClientTest_0028
597 * @tc.desc: QueryAddedPrinterList
598 * @tc.type: FUNC
599 * @tc.require:
600 */
601 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0028, TestSize.Level1)
602 {
603 OHOS::Print::PrintCupsClient printCupsClient;
604 std::vector<std::string> printerNameList;
605 printerNameList.push_back("testPrinterName");
606 printCupsClient.StartCupsdService();
607 EXPECT_EQ(printCupsClient.QueryAddedPrinterList(printerNameList), E_PRINT_NONE);
608 }
609
610 /**
611 * @tc.name: PrintCupsClientTest_0030
612 * @tc.desc: GetPPDFile
613 * @tc.type: FUNC
614 * @tc.require:
615 */
616 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0030, TestSize.Level1)
617 {
618 OHOS::Print::PrintCupsClient printCupsClient;
619 std::string printerName = "testPrinterName";
620 printCupsClient.StopCupsdService();
621 ppd_file_t *ppd = printCupsClient.GetPPDFile(printerName);
622 EXPECT_EQ(ppd, nullptr);
623 }
624
625 /**
626 * @tc.name: PrintCupsClientTest_0031
627 * @tc.desc: GetPPDFile
628 * @tc.type: FUNC
629 * @tc.require:
630 */
631 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0031, TestSize.Level1)
632 {
633 OHOS::Print::PrintCupsClient printCupsClient;
634 std::string printerName = "testPrinterName";
635 EXPECT_EQ(printCupsClient.StartCupsdService(), E_PRINT_NONE);
636 printCupsClient.GetPPDFile(printerName);
637 }
638
639 /**
640 * @tc.name: PrintCupsClientTest_0032
641 * @tc.desc: QueryPrinterAttrList
642 * @tc.type: FUNC
643 * @tc.require:
644 */
645 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0032, TestSize.Level1)
646 {
647 OHOS::Print::PrintCupsClient printCupsClient;
648 std::string printerName = "testPrinterName";
649 std::vector<std::string> keyList;
650 std::vector<std::string> valueList;
651 EXPECT_EQ(printCupsClient.QueryPrinterAttrList(printerName, keyList, valueList), E_PRINT_SERVER_FAILURE);
652 }
653
654 /**
655 * @tc.name: PrintCupsClientTest_0033
656 * @tc.desc: QueryPrinterInfoByPrinterId
657 * @tc.type: FUNC
658 * @tc.require:
659 */
660 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0033, TestSize.Level1)
661 {
662 OHOS::Print::PrintCupsClient printCupsClient;
663 std::string printerId = "testPrinterId";
664 PrinterInfo info;
665 info.SetPrinterName("testPrinterName");
666 EXPECT_EQ(printCupsClient.QueryPrinterInfoByPrinterId(printerId, info), E_PRINT_SERVER_FAILURE);
667 }
668
669 /**
670 * @tc.name: PrintCupsClientTest_0034
671 * @tc.desc: CheckPrinterMakeModel
672 * @tc.type: FUNC
673 * @tc.require:
674 */
675 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0034, TestSize.Level1)
676 {
677 OHOS::Print::PrintCupsClient printCupsClient;
678 JobParameters *jobParams = nullptr;
679 bool ret = printCupsClient.CheckPrinterMakeModel(jobParams);
680 EXPECT_EQ(ret, false);
681 }
682
683 /**
684 * @tc.name: PrintCupsClientTest_0036
685 * @tc.desc: VerifyPrintJob
686 * @tc.type: FUNC
687 * @tc.require:
688 */
689 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0036, TestSize.Level1)
690 {
691 OHOS::Print::PrintCupsClient printCupsClient;
692 JobParameters *jobParams = nullptr;
693 int num = 0;
694 uint32_t jobId = 1;
695 cups_option_t *options = nullptr;
696 http_t *http = nullptr;
697 bool ret = printCupsClient.VerifyPrintJob(jobParams, num, jobId, options, http);
698 EXPECT_EQ(ret, false);
699 delete jobParams;
700 delete options;
701 delete http;
702 }
703
704 /**
705 * @tc.name: PrintCupsClientTest_0039
706 * @tc.desc: UpdatePrintJobStateInJobParams
707 * @tc.type: FUNC
708 * @tc.require:
709 */
710 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0039, TestSize.Level1)
711 {
712 OHOS::Print::PrintCupsClient printCupsClient;
713 PrintJob testJob;
714 testJob.SetJobId(GetDefaultJobId());
715 std::vector<uint32_t> files = {1};
716 testJob.SetFdList(files);
717 OHOS::Print::PrintPageSize pageSize;
718 pageSize.SetId("pgid-1234");
719 testJob.SetPageSize(pageSize);
720 testJob.SetPrinterId("printid-1234");
721 testJob.SetOption(JOB_OPTIONS);
722 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
723 EXPECT_NE(jobParams, nullptr);
724 EXPECT_NE(jobParams->serviceAbility, nullptr);
725
726 uint32_t state = PRINT_JOB_BLOCKED;
727 uint32_t subState = PRINT_JOB_BLOCKED_UNKNOWN;
728 printCupsClient.UpdatePrintJobStateInJobParams(jobParams, state, subState);
729
730 auto jobId = jobParams->serviceJobId;
731 auto userData = jobParams->serviceAbility->GetUserDataByJobId(jobId);
732 EXPECT_EQ(userData, nullptr);
733 delete jobParams;
734 }
735
736 /**
737 * @tc.name: PrintCupsClientTest_0042
738 * @tc.desc: UpdateJobStatus
739 * @tc.type: FUNC
740 * @tc.require:
741 */
742 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0042, TestSize.Level1)
743 {
744 OHOS::Print::PrintCupsClient printCupsClient;
745 EXPECT_FALSE(printCupsClient.CheckPrinterDriverExist(nullptr));
746 char makeModel[128] {};
747 EXPECT_FALSE(printCupsClient.CheckPrinterDriverExist(makeModel));
748 DEFAULT_MAKE_MODEL.copy(makeModel, DEFAULT_MAKE_MODEL.length() + 1);
749 EXPECT_TRUE(printCupsClient.CheckPrinterDriverExist(makeModel));
750 BSUNI_PPD_NAME.copy(makeModel, BSUNI_PPD_NAME.length() + 1);
751 EXPECT_TRUE(printCupsClient.CheckPrinterDriverExist(makeModel));
752 REMOTE_PRINTER_MAKE_MODEL.copy(makeModel, REMOTE_PRINTER_MAKE_MODEL.length() + 1);
753 EXPECT_FALSE(printCupsClient.CheckPrinterDriverExist(makeModel));
754 }
755
756 /**
757 * @tc.name: PrintCupsClientTest_0043
758 * @tc.desc: UpdateJobStatus
759 * @tc.type: FUNC
760 * @tc.require:
761 */
762 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0043, TestSize.Level1)
763 {
764 OHOS::Print::PrintCupsClient printCupsClient;
765 printCupsClient.StartMonitor();
766 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
767 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
768 printCupsClient.StartMonitor();
769 EXPECT_EQ(printCupsClient.jobMonitorList_.size(), 0);
770 }
771
772 /**
773 * @tc.name: PrintCupsClientTest_0047
774 * @tc.desc: JobStatusCallback
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0047, TestSize.Level1)
779 {
780 OHOS::Print::PrintCupsClient printCupsClient;
781 printCupsClient.IsPrinterStopped(nullptr);
782 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
783 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
784 EXPECT_FALSE(printCupsClient.IsPrinterStopped(param));
785 }
786
787 /**
788 * @tc.name: PrintCupsClientTest_0048
789 * @tc.desc: JobStatusCallback
790 * @tc.type: FUNC
791 * @tc.require:
792 */
793 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0048, TestSize.Level1)
794 {
795 OHOS::Print::PrintCupsClient printCupsClient;
796 printCupsClient.IfContinueToHandleJobState(nullptr);
797 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
798 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
799 EXPECT_TRUE(printCupsClient.IfContinueToHandleJobState(param));
800 param->isCanceled = true;
801 EXPECT_FALSE(printCupsClient.IfContinueToHandleJobState(param));
802 }
803
804 /**
805 * @tc.name: PrintCupsClientTest_0049
806 * @tc.desc: JobStatusCallback
807 * @tc.type: FUNC
808 * @tc.require:
809 */
810 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0049, TestSize.Level1)
811 {
812 OHOS::Print::PrintCupsClient printCupsClient;
813 printCupsClient.JobStatusCallback(nullptr);
814 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
815 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
816 param->substate = 0;
817 param->job_state = IPP_JOB_COMPLETED;
818 param->isBlock = false;
819 param->timesOfSameState = 0;
820 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
821 param->isBlock = true;
822 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
823 param->timesOfSameState = STATE_UPDATE_STEP;
824 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
825 }
826
827 /**
828 * @tc.name: PrintCupsClientTest_0050
829 * @tc.desc: JobStatusCallback
830 * @tc.type: FUNC
831 * @tc.require:
832 */
833 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0050, TestSize.Level1)
834 {
835 OHOS::Print::PrintCupsClient printCupsClient;
836 printCupsClient.JobStatusCallback(nullptr);
837 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
838 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
839 param->substate = 0;
840 param->job_state = IPP_JOB_PROCESSING;
841 param->isBlock = false;
842 param->timesOfSameState = 0;
843 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
844 param->isBlock = true;
845 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
846 param->timesOfSameState = STATE_UPDATE_STEP;
847 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
848 }
849
850 /**
851 * @tc.name: PrintCupsClientTest_0051
852 * @tc.desc: JobStatusCallback
853 * @tc.type: FUNC
854 * @tc.require:
855 */
856 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0051, TestSize.Level1)
857 {
858 OHOS::Print::PrintCupsClient printCupsClient;
859 printCupsClient.JobStatusCallback(nullptr);
860 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
861 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
862 param->substate = 0;
863 param->job_state = IPP_JOB_CANCELED;
864 param->isBlock = false;
865 param->timesOfSameState = 0;
866 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
867 param->isBlock = true;
868 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
869 param->timesOfSameState = STATE_UPDATE_STEP;
870 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
871 }
872
873 /**
874 * @tc.name: PrintCupsClientTest_0052
875 * @tc.desc: JobStatusCallback
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0052, TestSize.Level1)
880 {
881 OHOS::Print::PrintCupsClient printCupsClient;
882 printCupsClient.JobStatusCallback(nullptr);
883 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
884 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
885 param->substate = 0;
886 param->job_state = IPP_JOB_ABORTED;
887 param->isBlock = false;
888 param->timesOfSameState = 0;
889 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
890 param->isBlock = true;
891 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
892 param->timesOfSameState = STATE_UPDATE_STEP;
893 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
894 }
895
896 /**
897 * @tc.name: PrintCupsClientTest_0053
898 * @tc.desc: ReportBlockedReason
899 * @tc.type: FUNC
900 * @tc.require:
901 */
902 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0053, TestSize.Level1)
903 {
904 OHOS::Print::PrintCupsClient printCupsClient;
905 printCupsClient.JobStatusCallback(nullptr);
906 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
907 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
908 param->substate = 0;
909 param->job_state = IPP_JOB_STOPPED;
910 param->isBlock = false;
911 param->timesOfSameState = 0;
912 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
913 param->isBlock = true;
914 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
915 param->timesOfSameState = STATE_UPDATE_STEP;
916 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
917 }
918
919 /**
920 * @tc.name: PrintCupsClientTest_0054
921 * @tc.desc: ReportBlockedReason
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0054, TestSize.Level1)
926 {
927 OHOS::Print::PrintCupsClient printCupsClient;
928 printCupsClient.JobStatusCallback(nullptr);
929 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
930 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
931 param->substate = 0;
932 param->job_state = IPP_JOB_PENDING;
933 param->isBlock = false;
934 param->timesOfSameState = 0;
935 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
936 param->isBlock = true;
937 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
938 param->timesOfSameState = STATE_UPDATE_STEP;
939 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
940 }
941
942 /**
943 * @tc.name: PrintCupsClientTest_0055
944 * @tc.desc: ReportBlockedReason
945 * @tc.type: FUNC
946 * @tc.require:
947 */
948 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0055, TestSize.Level1)
949 {
950 OHOS::Print::PrintCupsClient printCupsClient;
951 printCupsClient.JobStatusCallback(nullptr);
952 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
953 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
954 param->substate = 0;
955 param->job_state = IPP_JOB_HELD;
956 param->isBlock = false;
957 param->timesOfSameState = 0;
958 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
959 param->isBlock = true;
960 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
961 param->timesOfSameState = STATE_UPDATE_STEP;
962 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
963 }
964
965 /**
966 * @tc.name: PrintCupsClientTest_0056
967 * @tc.desc: QueryJobState
968 * @tc.type: FUNC
969 * @tc.require:
970 */
971 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0056, TestSize.Level1)
972 {
973 OHOS::Print::PrintCupsClient printCupsClient;
974 printCupsClient.ParseStateReasons(nullptr);
975 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
976 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
977 param->isPrinterStopped = false;
978 printCupsClient.ParseStateReasons(param);
979 EXPECT_EQ(param->substate, 0);
980 param->isPrinterStopped = true;
981 printCupsClient.ParseStateReasons(param);
982 EXPECT_EQ(param->substate, 99);
983 }
984
985 /**
986 * @tc.name: PrintCupsClientTest_0057
987 * @tc.desc: QueryJobState
988 * @tc.type: FUNC
989 * @tc.require:
990 */
991 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0057, TestSize.Level1)
992 {
993 OHOS::Print::PrintCupsClient printCupsClient;
994 printCupsClient.GetBlockedAndUpdateSubstate(nullptr, STATE_POLICY_STANDARD,
995 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED);
996 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
997 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
998 param->substate = 0;
999 param->isBlock = false;
1000 param->timesOfSameState = 0;
1001 std::string reason = "media-jam-error";
1002 reason.copy(param->job_printer_state_reasons, reason.length() + 1);
1003 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_STANDARD,
1004 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1005 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_BLOCK,
1006 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1007 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_HINT,
1008 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1009 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1010 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1011 param->timesOfSameState = STATE_UPDATE_STEP;
1012 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1013 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1014 }
1015
1016 /**
1017 * @tc.name: PrintCupsClientTest_0058
1018 * @tc.desc: QueryJobState
1019 * @tc.type: FUNC
1020 * @tc.require:
1021 */
1022 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0058, TestSize.Level1)
1023 {
1024 OHOS::Print::PrintCupsClient printCupsClient;
1025 printCupsClient.GetBlockedAndUpdateSubstate(nullptr, STATE_POLICY_STANDARD,
1026 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED);
1027 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1028 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1029 param->substate = 0;
1030 param->isBlock = false;
1031 param->timesOfSameState = 0;
1032 std::string reason = "media-jam-warning";
1033 reason.copy(param->job_printer_state_reasons, reason.length() + 1);
1034 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_STANDARD,
1035 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1036 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_BLOCK,
1037 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1038 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_HINT,
1039 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1040 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1041 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1042 param->timesOfSameState = STATE_UPDATE_STEP;
1043 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1044 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1045 }
1046
1047 /**
1048 * @tc.name: PrintCupsClientTest_0059
1049 * @tc.desc: CancelCupsJob
1050 * @tc.type: FUNC
1051 * @tc.require:
1052 */
1053 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0059, TestSize.Level1)
1054 {
1055 OHOS::Print::PrintCupsClient printCupsClient;
1056 int num = printCupsClient.jobQueue_.size();
1057 printCupsClient.CancelCupsJob(GetDefaultJobId());
1058 if (num > 0) {
1059 num = num - 1;
1060 }
1061 EXPECT_EQ(printCupsClient.jobQueue_.size(), num);
1062 }
1063
1064 /**
1065 * @tc.name: PrintCupsClientTest_0060
1066 * @tc.desc: CancelCupsJob
1067 * @tc.type: FUNC
1068 * @tc.require:
1069 */
1070 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0060, TestSize.Level1)
1071 {
1072 OHOS::Print::PrintCupsClient printCupsClient;
1073 std::string serviceJobId = "0";
1074 PrintJob testJob;
1075 testJob.SetJobId(GetDefaultJobId());
1076 std::vector<uint32_t> files = {1};
1077 testJob.SetFdList(files);
1078 OHOS::Print::PrintPageSize pageSize;
1079 pageSize.SetId("pgid-1234");
1080 testJob.SetPageSize(pageSize);
1081 testJob.SetPrinterId("printid-1234");
1082 testJob.SetOption(JOB_OPTIONS);
1083 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1084 EXPECT_EQ(jobParams->jobOriginatingUserName, "default");
1085 printCupsClient.jobQueue_.push_back(jobParams);
1086 PRINT_HILOGI("CancelCupsJob(): printCupsClient.jobQueue_.size(): %{public}u", printCupsClient.jobQueue_.size());
1087 printCupsClient.CancelCupsJob(serviceJobId);
1088 }
1089
1090 /**
1091 * @tc.name: PrintCupsClientTest_0061
1092 * @tc.desc: CancelCupsJob
1093 * @tc.type: FUNC
1094 * @tc.require:
1095 */
1096 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0061, TestSize.Level1)
1097 {
1098 OHOS::Print::PrintCupsClient printCupsClient;
1099 std::string serviceJobId = "1";
1100 PrintJob testJob;
1101 testJob.SetJobId(GetDefaultJobId());
1102 std::vector<uint32_t> files = {1};
1103 testJob.SetFdList(files);
1104 OHOS::Print::PrintPageSize pageSize;
1105 pageSize.SetId("pgid-1234");
1106 testJob.SetPageSize(pageSize);
1107 testJob.SetPrinterId("printid-1234");
1108 testJob.SetOption(JOB_OPTIONS);
1109 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1110 EXPECT_EQ(jobParams->jobOriginatingUserName, "default");
1111 printCupsClient.jobQueue_.push_back(jobParams);
1112 printCupsClient.CancelCupsJob(serviceJobId);
1113 }
1114
1115 /**
1116 * @tc.name: PrintCupsClientTest_0062
1117 * @tc.desc: CancelCupsJob
1118 * @tc.type: FUNC
1119 * @tc.require:
1120 */
1121 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0062, TestSize.Level1)
1122 {
1123 OHOS::Print::PrintCupsClient printCupsClient;
1124 std::string serviceJobId = TEST_SERVICE_JOB_ID;
1125 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1126 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1127 printCupsClient.jobMonitorList_ = std::vector<std::shared_ptr<JobMonitorParam>> (1, param);
1128 printCupsClient.CancelCupsJob("invalidId");
1129 EXPECT_FALSE(param->isCanceled);
1130 printCupsClient.CancelCupsJob(TEST_SERVICE_JOB_ID);
1131 EXPECT_TRUE(param->isCanceled);
1132 }
1133
1134 /**
1135 * @tc.name: PrintCupsClientTest_0063
1136 * @tc.desc: QueryJobState
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 */
1140 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0063, TestSize.Level1)
1141 {
1142 OHOS::Print::PrintCupsClient printCupsClient;
1143 printCupsClient.GetBlockedAndUpdateSubstate(nullptr, STATE_POLICY_STANDARD,
1144 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED);
1145 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1146 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1147 param->substate = 0;
1148 param->isBlock = false;
1149 param->timesOfSameState = 0;
1150 std::string reason = "null";
1151 reason.copy(param->job_printer_state_reasons, reason.length() + 1);
1152 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_STANDARD,
1153 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1154 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_BLOCK,
1155 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1156 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_HINT,
1157 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1158 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1159 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1160 param->timesOfSameState = STATE_UPDATE_STEP;
1161 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1162 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1163 }
1164
1165 /**
1166 * @tc.name: PrintCupsClientTest_0066
1167 * @tc.desc: BuildJobParameters
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0066, TestSize.Level1)
1172 {
1173 OHOS::Print::PrintCupsClient printCupsClient;
1174 PrintJob testJob;
1175 testJob.SetJobId(GetDefaultJobId());
1176 std::vector<uint32_t> files = {1};
1177 testJob.SetFdList(files);
1178 OHOS::Print::PrintPageSize pageSize;
1179 pageSize.SetId("pgid-1234");
1180 testJob.SetPageSize(pageSize);
1181 testJob.SetPrinterId("printid-1234");
1182 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1183 EXPECT_EQ(jobParams, nullptr);
1184
1185 testJob.SetOption("test");
1186 printCupsClient.BuildJobParameters(testJob);
1187 EXPECT_EQ(jobParams, nullptr);
1188 delete jobParams;
1189 }
1190
1191 /**
1192 * @tc.name: PrintCupsClientTest_0067
1193 * @tc.desc: BuildJobParameters
1194 * @tc.type: FUNC
1195 * @tc.require:
1196 */
1197 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0067, TestSize.Level1)
1198 {
1199 OHOS::Print::PrintCupsClient printCupsClient;
1200 PrintJob testJob;
1201 testJob.SetJobId(GetDefaultJobId());
1202 std::vector<uint32_t> files = {1};
1203 testJob.SetFdList(files);
1204 OHOS::Print::PrintPageSize pageSize;
1205 pageSize.SetId("pgid-1234");
1206 testJob.SetPageSize(pageSize);
1207 testJob.SetPrinterId("printid-1234");
1208 testJob.SetIsLandscape(true);
1209 testJob.SetOption(R"({"key": "value"})");
1210 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1211 EXPECT_EQ(jobParams, nullptr);
1212
1213 Json::Value optionJson;
1214 PrintJsonUtil::Parse(testJob.GetOption(), optionJson);
1215 optionJson["printerUri"] = "ipp://192.168.0.1:111/ipp/print";
1216 optionJson["printerName"] = "printer1";
1217 optionJson["documentFormat"] = "application/pdf";
1218 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1219 jobParams = printCupsClient.BuildJobParameters(testJob);
1220 EXPECT_EQ(jobParams->printerUri, optionJson["printerUri"].asString());
1221 EXPECT_EQ(jobParams->printerName, PrintUtil::StandardizePrinterName(optionJson["printerName"].asString()));
1222 EXPECT_EQ(jobParams->documentFormat, optionJson["documentFormat"].asString());
1223
1224 optionJson["cupsOptions"] = "testCupsOptions";
1225 optionJson["printQuality"] = "printQuality";
1226 optionJson["jobName"] = "jobName";
1227 optionJson["mediaType"] = "mediaType";
1228 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1229 jobParams = printCupsClient.BuildJobParameters(testJob);
1230 EXPECT_EQ(jobParams->printerAttrsOption_cupsOption, optionJson["cupsOptions"].asString());
1231 EXPECT_EQ(jobParams->printQuality, optionJson["printQuality"].asString());
1232 EXPECT_EQ(jobParams->jobName, optionJson["jobName"].asString());
1233 EXPECT_EQ(jobParams->mediaType, optionJson["mediaType"].asString());
1234
1235 optionJson["printQuality"] = 1;
1236 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1237 jobParams = printCupsClient.BuildJobParameters(testJob);
1238 EXPECT_EQ(jobParams->printQuality, CUPS_PRINT_QUALITY_NORMAL);
1239
1240 EXPECT_EQ(jobParams->isAutoRotate, true); // default true
1241 optionJson["isAutoRotate"] = false;
1242 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1243 jobParams = printCupsClient.BuildJobParameters(testJob);
1244 EXPECT_EQ(jobParams->isAutoRotate, optionJson["isAutoRotate"].asBool());
1245 }
1246
1247 /**
1248 * @tc.name: PrintCupsClientTest_0068
1249 * @tc.desc: DumpJobParameters
1250 * @tc.type: FUNC
1251 * @tc.require:
1252 */
1253 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0068, TestSize.Level1)
1254 {
1255 OHOS::Print::PrintCupsClient printCupsClient;
1256 PrintJob testJob;
1257 testJob.SetJobId(GetDefaultJobId());
1258 std::vector<uint32_t> files = {1};
1259 testJob.SetFdList(files);
1260 testJob.SetColorMode(1);
1261 testJob.SetCopyNumber(1);
1262 testJob.SetDuplexMode(0);
1263 OHOS::Print::PrintPageSize pageSize;
1264 pageSize.SetId("pgid-1234");
1265 testJob.SetPageSize(pageSize);
1266 testJob.SetPrinterId("printid-1234");
1267 testJob.SetOption(JOB_OPTIONS);
1268 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1269 std::string option = testJob.GetOption();
1270 Json::Value optionJson;
1271 PrintJsonUtil::Parse(option, optionJson);
1272 EXPECT_EQ(jobParams->jobName, optionJson["jobName"].asString());
1273 EXPECT_EQ(jobParams->mediaType, optionJson["mediaType"].asString());
1274 EXPECT_EQ(jobParams->printQuality, optionJson["printQuality"].asString());
1275 EXPECT_EQ(jobParams->printerName, optionJson["printerName"].asString());
1276 EXPECT_EQ(jobParams->printerUri, optionJson["printerUri"].asString());
1277 EXPECT_EQ(jobParams->documentFormat, optionJson["documentFormat"].asString());
1278 EXPECT_EQ(jobParams->isAutoRotate, optionJson["isAutoRotate"].asBool());
1279 printCupsClient.DumpJobParameters(jobParams);
1280 delete jobParams;
1281 }
1282
1283 /**
1284 * @tc.name: PrintCupsClientTest_0069
1285 * @tc.desc: GetMedieSize
1286 * @tc.type: FUNC
1287 * @tc.require:
1288 */
1289 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0069, TestSize.Level1)
1290 {
1291 OHOS::Print::PrintCupsClient printCupsClient;
1292 PrintJob testJob;
1293 testJob.SetJobId(GetDefaultJobId());
1294 std::vector<uint32_t> files = {1};
1295 testJob.SetFdList(files);
1296 testJob.SetColorMode(1);
1297 testJob.SetCopyNumber(1);
1298 testJob.SetDuplexMode(0);
1299 OHOS::Print::PrintPageSize pageSize;
1300 pageSize.SetId("pgid-1234");
1301 testJob.SetPageSize(pageSize);
1302 testJob.SetPrinterId("printid-1234");
1303 testJob.SetOption(JOB_OPTIONS);
1304 std::string pageSizeName = printCupsClient.GetMedieSize(testJob);
1305 EXPECT_EQ("PrintPageSize", pageSizeName);
1306 }
1307
1308 /**
1309 * @tc.name: PrintCupsClientTest_0070
1310 * @tc.desc: GetDulpexString
1311 * @tc.type: FUNC
1312 * @tc.require:
1313 */
1314 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0070, TestSize.Level1)
1315 {
1316 OHOS::Print::PrintCupsClient printCupsClient;
1317 uint32_t duplexCode = 0;
1318 std::string ret0 = printCupsClient.GetDulpexString(duplexCode);
1319 EXPECT_EQ(ret0, CUPS_SIDES_ONE_SIDED);
1320
1321 duplexCode = 1;
1322 std::string ret1 = printCupsClient.GetDulpexString(duplexCode);
1323 EXPECT_EQ(ret1, CUPS_SIDES_TWO_SIDED_PORTRAIT);
1324
1325 duplexCode = 2;
1326 std::string ret2 = printCupsClient.GetDulpexString(duplexCode);
1327 EXPECT_EQ(ret2, CUPS_SIDES_TWO_SIDED_LANDSCAPE);
1328
1329 duplexCode = 3;
1330 std::string ret3 = printCupsClient.GetDulpexString(duplexCode);
1331 EXPECT_EQ(ret3, CUPS_SIDES_ONE_SIDED);
1332 }
1333
1334 /**
1335 * @tc.name: PrintCupsClientTest_0071
1336 * @tc.desc: GetColorString
1337 * @tc.type: FUNC
1338 * @tc.require:
1339 */
1340 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0071, TestSize.Level1)
1341 {
1342 OHOS::Print::PrintCupsClient printCupsClient;
1343 uint32_t colorCode = 0;
1344 std::string ret0 = printCupsClient.GetColorString(colorCode);
1345 EXPECT_EQ(ret0, CUPS_PRINT_COLOR_MODE_MONOCHROME);
1346
1347 colorCode = 1;
1348 std::string ret1 = printCupsClient.GetColorString(colorCode);
1349 EXPECT_EQ(ret1, CUPS_PRINT_COLOR_MODE_COLOR);
1350
1351 colorCode = 2;
1352 std::string ret2 = printCupsClient.GetColorString(colorCode);
1353 EXPECT_EQ(ret2, CUPS_PRINT_COLOR_MODE_AUTO);
1354 }
1355
1356 /**
1357 * @tc.name: PrintCupsClientTest_0073
1358 * @tc.desc: IsPrinterExist
1359 * @tc.type: FUNC
1360 * @tc.require:
1361 */
1362 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0073, TestSize.Level1)
1363 {
1364 OHOS::Print::PrintCupsClient printCupsClient;
1365 const char *printerUri = "ipp://192.168.186.1:631/ipp/print";
1366 const char *printerName = "DIRECT-PixLab_V1-0105";
1367 const char *ppdName = "DIRECT-PixLab_V1-0105.ppd";
1368 EXPECT_EQ(printCupsClient.IsPrinterExist(printerUri, printerName, ppdName), E_PRINT_NONE);
1369 }
1370
1371 /**
1372 * @tc.name: PrintCupsClientTest_0074
1373 * @tc.desc: ConvertInchTo100MM
1374 * @tc.type: FUNC
1375 * @tc.require:
1376 */
1377 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0074, TestSize.Level1)
1378 {
1379 OHOS::Print::PrintCupsClient printCupsClient;
1380 float num = 1000;
1381 float ret = printCupsClient.ConvertInchTo100MM(num);
1382 EXPECT_EQ(ret, 2540);
1383 }
1384
1385 /**
1386 * @tc.name: PrintCupsClientTest_0075
1387 * @tc.desc: IsIpConflict
1388 * @tc.type: FUNC
1389 * @tc.require:
1390 */
1391 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0075, TestSize.Level1)
1392 {
1393 OHOS::Print::PrintCupsClient printCupsClient;
1394 std::string printerId = "com.ohos.spooler:usb://DIRECT-PixLab_V1-1620";
1395 std::string nic = "";
1396 bool ret1 = printCupsClient.IsIpConflict(printerId, nic);
1397 EXPECT_EQ(ret1, false);
1398
1399 printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1400 bool ret2 = printCupsClient.IsIpConflict(printerId, nic);
1401 EXPECT_EQ(ret2, false);
1402 }
1403
1404 /**
1405 * @tc.name: PrintCupsClientTest_0077
1406 * @tc.desc: DiscoverUsbPrinters
1407 * @tc.type: FUNC
1408 * @tc.require:
1409 */
1410 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0077, TestSize.Level1)
1411 {
1412 OHOS::Print::PrintCupsClient printCupsClient;
1413 std::vector<PrinterInfo> printers;
1414 printCupsClient.DiscoverUsbPrinters(printers);
1415 EXPECT_EQ(printers.size(), 0);
1416 }
1417
1418 /**
1419 * @tc.name: PrintCupsClientTest_0078
1420 * @tc.desc: BuildJobParameters
1421 * @tc.type: FUNC
1422 * @tc.require:
1423 */
1424 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0078, TestSize.Level1)
1425 {
1426 OHOS::Print::PrintCupsClient printCupsClient;
1427 PrintJob testJob;
1428 testJob.SetJobId(GetDefaultJobId());
1429 std::vector<uint32_t> files = {1};
1430 testJob.SetFdList(files);
1431 OHOS::Print::PrintPageSize pageSize;
1432 pageSize.SetId("pgid-1234");
1433 testJob.SetPageSize(pageSize);
1434 testJob.SetPrinterId("printid-1234");
1435 testJob.SetOption(R"({"key": "value"})");
1436
1437 Json::Value optionJson;
1438 PrintJsonUtil::Parse(testJob.GetOption(), optionJson);
1439 optionJson["printerUri"] = 1;
1440 optionJson["printerName"] = "printer1";
1441 optionJson["documentFormat"] = "application/pdf";
1442 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1443 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1444 EXPECT_EQ(jobParams, nullptr);
1445
1446 optionJson["printerUri"] = "ipp://192.168.0.1:111/ipp/print";
1447 optionJson["printerName"] = 1;
1448 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1449 jobParams = printCupsClient.BuildJobParameters(testJob);
1450 EXPECT_EQ(jobParams, nullptr);
1451
1452 optionJson["printerName"] = "printer1";
1453 optionJson["documentFormat"] = 1;
1454 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1455 jobParams = printCupsClient.BuildJobParameters(testJob);
1456 EXPECT_EQ(jobParams, nullptr);
1457 }
1458
1459 /**
1460 * @tc.name: PrintCupsClientTest_0079
1461 * @tc.desc: HandleFiles
1462 * @tc.type: FUNC
1463 * @tc.require:
1464 */
1465 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0079, TestSize.Level1)
1466 {
1467 OHOS::Print::PrintCupsClient printCupsClient;
1468 http_t *http = nullptr;
1469 JobParameters *jobParams = nullptr;
1470 int32_t numFiles = 1;
1471 int32_t jobId = 1;
1472 EXPECT_EQ(printCupsClient.HandleFiles(jobParams, numFiles, http, jobId), false);
1473 PrintJob testJob;
1474 testJob.SetJobId(GetDefaultJobId());
1475 std::vector<uint32_t> files = {1};
1476 testJob.SetFdList(files);
1477 testJob.SetColorMode(1);
1478 testJob.SetCopyNumber(1);
1479 testJob.SetDuplexMode(0);
1480 OHOS::Print::PrintPageSize pageSize;
1481 pageSize.SetId("pgid-1234");
1482 testJob.SetPageSize(pageSize);
1483 testJob.SetPrinterId("printid-1234");
1484 testJob.SetOption(JOB_OPTIONS);
1485 jobParams = printCupsClient.BuildJobParameters(testJob);
1486 delete http;
1487 delete jobParams;
1488 }
1489
1490 /**
1491 * @tc.name: PrintCupsClientTest_0081
1492 * @tc.desc: UpdateJobState
1493 * @tc.type: FUNC
1494 * @tc.require:
1495 */
1496 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0081, TestSize.Level1)
1497 {
1498 OHOS::Print::PrintCupsClient printCupsClient;
1499 EXPECT_FALSE(printCupsClient.UpdateJobState(nullptr, nullptr));
1500 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1501 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1502 EXPECT_FALSE(printCupsClient.UpdateJobState(param, nullptr));
1503 }
1504
1505 /**
1506 * @tc.name: PrintCupsClientTest_0082
1507 * @tc.desc: ResumePrinter
1508 * @tc.type: FUNC
1509 * @tc.require:
1510 */
1511 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0082, TestSize.Level1)
1512 {
1513 OHOS::Print::PrintCupsClient printCupsClient;
1514 std::string printerName = "testPrinterName";
1515 EXPECT_EQ(printCupsClient.ResumePrinter(printerName), false);
1516 printCupsClient.printAbility_ = nullptr;
1517 EXPECT_EQ(printCupsClient.ResumePrinter(printerName), false);
1518 }
1519
1520 /**
1521 * @tc.name: PrintCupsClientTest_0083
1522 * @tc.desc: FillLandscapeOptions
1523 * @tc.type: FUNC
1524 * @tc.require:
1525 */
1526 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0083, TestSize.Level1)
1527 {
1528 OHOS::Print::PrintCupsClient printCupsClient;
1529 PrintJob testJob;
1530 testJob.SetJobId(GetDefaultJobId());
1531 std::vector<uint32_t> files = {1};
1532 testJob.SetFdList(files);
1533 OHOS::Print::PrintPageSize pageSize;
1534 pageSize.SetId("pgid-1234");
1535 testJob.SetPageSize(pageSize);
1536 testJob.SetPrinterId("printid-1234");
1537 testJob.SetIsLandscape(true);
1538 testJob.SetOption(JOB_OPTIONS);
1539 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1540 jobParams->isAutoRotate = true;
1541 jobParams->isLandscape = true;
1542 int numOptions = 0;
1543 cups_option_t *options = nullptr;
1544 printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options);
1545 EXPECT_EQ(numOptions, 0);
1546 delete jobParams;
1547 delete options;
1548 }
1549
1550 /**
1551 * @tc.name: PrintCupsClientTest_0084
1552 * @tc.desc: FillLandscapeOptions
1553 * @tc.type: FUNC
1554 * @tc.require:
1555 */
1556 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0084, TestSize.Level1)
1557 {
1558 OHOS::Print::PrintCupsClient printCupsClient;
1559 PrintJob testJob;
1560 testJob.SetJobId(GetDefaultJobId());
1561 std::vector<uint32_t> files = {1};
1562 testJob.SetFdList(files);
1563 OHOS::Print::PrintPageSize pageSize;
1564 pageSize.SetId("pgid-1234");
1565 testJob.SetPageSize(pageSize);
1566 testJob.SetPrinterId("printid-1234");
1567 testJob.SetIsLandscape(true);
1568 testJob.SetOption(JOB_OPTIONS);
1569 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1570 jobParams->isAutoRotate = true;
1571 jobParams->isLandscape = false;
1572 int numOptions = 0;
1573 cups_option_t *options = nullptr;
1574 printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options);
1575 EXPECT_EQ(numOptions, 0);
1576 delete jobParams;
1577 delete options;
1578 }
1579
1580 /**
1581 * @tc.name: PrintCupsClientTest_0085
1582 * @tc.desc: FillLandscapeOptions
1583 * @tc.type: FUNC
1584 * @tc.require:
1585 */
1586 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0085, TestSize.Level1)
1587 {
1588 OHOS::Print::PrintCupsClient printCupsClient;
1589 PrintJob testJob;
1590 testJob.SetJobId(GetDefaultJobId());
1591 std::vector<uint32_t> files = {1};
1592 testJob.SetFdList(files);
1593 OHOS::Print::PrintPageSize pageSize;
1594 pageSize.SetId("pgid-1234");
1595 testJob.SetPageSize(pageSize);
1596 testJob.SetPrinterId("printid-1234");
1597 testJob.SetIsLandscape(true);
1598 testJob.SetOption(JOB_OPTIONS);
1599 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1600 jobParams->isAutoRotate = false;
1601 jobParams->isLandscape = false;
1602 int numOptions = 0;
1603 cups_option_t *options = nullptr;
1604 printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options);
1605 EXPECT_EQ(numOptions, 0);
1606 delete jobParams;
1607 delete options;
1608 }
1609
1610 /**
1611 * @tc.name: PrintCupsClientTest_0086
1612 * @tc.desc: FillLandscapeOptions
1613 * @tc.type: FUNC
1614 * @tc.require:
1615 */
1616 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0086, TestSize.Level1)
1617 {
1618 OHOS::Print::PrintCupsClient printCupsClient;
1619 PrintJob testJob;
1620 testJob.SetJobId(GetDefaultJobId());
1621 std::vector<uint32_t> files = {1};
1622 testJob.SetFdList(files);
1623 OHOS::Print::PrintPageSize pageSize;
1624 pageSize.SetId("pgid-1234");
1625 testJob.SetPageSize(pageSize);
1626 testJob.SetPrinterId("printid-1234");
1627 testJob.SetIsLandscape(true);
1628 testJob.SetOption(JOB_OPTIONS);
1629 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob);
1630 jobParams->isAutoRotate = false;
1631 jobParams->isLandscape = true;
1632 int numOptions = 0;
1633 cups_option_t *options = nullptr;
1634 printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options);
1635 EXPECT_EQ(numOptions, 0);
1636 delete jobParams;
1637 delete options;
1638 }
1639
1640 /**
1641 * @tc.name: PrintCupsClientTest_0087
1642 * @tc.desc: DeviceCb_ShouldAddPrinterInfo_WhenDeviceUriStartsWithUSBAndPrinterMakeIsNotUnknown
1643 * @tc.type: FUNC
1644 * @tc.require:
1645 */
1646 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0087, TestSize.Level1)
1647 {
1648 // Arrange
1649 std::string deviceUri = "usb://printer";
1650 std::string deviceClass = "printer";
1651 std::string deviceId = "model123";
1652 std::string deviceInfo = "model123";
1653 std::string deviceMakeAndModel = "model123";
1654 std::string deviceLocation = "location123";
1655 void *userData = nullptr;
1656 // Act
1657 ClearUsbPrinters();
1658 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1659 deviceUri.c_str(), deviceLocation.c_str(), userData);
1660 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1661 deviceUri.c_str(), nullptr, userData);
1662 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1663 "usb://printer_serial=123&111", deviceLocation.c_str(), userData);
1664 // Assert
1665 auto usbPrinters = GetUsbPrinters();
1666 EXPECT_EQ(usbPrinters.size(), 3);
1667 EXPECT_STREQ(usbPrinters[0].GetUri().c_str(), deviceUri.c_str());
1668 EXPECT_STREQ(usbPrinters[0].GetPrinterMake().c_str(), deviceMakeAndModel.c_str());
1669 ClearUsbPrinters();
1670 }
1671
1672 /**
1673 * @tc.name: PrintCupsClientTest_0088
1674 * @tc.desc: DeviceCb_ShouldNotAddPrinterInfo_WhenDeviceUriDoesNotStartWithUSB
1675 * @tc.type: FUNC
1676 * @tc.require:
1677 */
1678 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0088, TestSize.Level1)
1679 {
1680 // Arrange
1681 std::string deviceUri = "network://printer";
1682 std::string deviceClass = "printer";
1683 std::string deviceId = "model123";
1684 std::string deviceInfo = "model123";
1685 std::string deviceMakeAndModel = "model123";
1686 std::string deviceLocation = "location123";
1687 void *userData = nullptr;
1688 // Act
1689 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1690 deviceUri.c_str(), deviceLocation.c_str(), userData);
1691 // Assert
1692 auto usbPrinters = GetUsbPrinters();
1693 EXPECT_EQ(usbPrinters.size(), 0);
1694 }
1695
1696 /**
1697 * @tc.name: PrintCupsClientTest_0089
1698 * @tc.desc: DeviceCb_ShouldNotAddPrinterInfo_WhenPrinterMakeIsUnknown
1699 * @tc.type: FUNC
1700 * @tc.require:
1701 */
1702 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0089, TestSize.Level1)
1703 {
1704 // Arrange
1705 std::string deviceUri = "usb://printer";
1706 std::string deviceClass = "printer";
1707 std::string deviceId = "model123";
1708 std::string deviceInfo = "model123";
1709 std::string deviceMakeAndModel = "Unknown";
1710 std::string deviceLocation = "location123";
1711 void *userData = nullptr;
1712 // Act
1713 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1714 deviceUri.c_str(), deviceLocation.c_str(), userData);
1715 // Assert
1716 auto usbPrinters = GetUsbPrinters();
1717 EXPECT_EQ(usbPrinters.size(), 0);
1718 }
1719
1720 /**
1721 * @tc.name: PrintCupsClientTest_0090
1722 * @tc.desc: DeviceCb_ShouldNotAddPrinterInfo_WhenParamNull
1723 * @tc.type: FUNC
1724 * @tc.require:
1725 */
1726 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0090, TestSize.Level1)
1727 {
1728 // Arrange
1729 std::string deviceUri = "usb://printer";
1730 std::string deviceClass = "printer";
1731 std::string deviceId = "model123";
1732 std::string deviceInfo = "model123";
1733 std::string deviceMakeAndModel = "Unknown";
1734 std::string deviceLocation = "location123";
1735 void *userData = nullptr;
1736 // Act
1737 DeviceCb(nullptr, deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1738 deviceUri.c_str(), deviceLocation.c_str(), userData);
1739 DeviceCb(deviceClass.c_str(), nullptr, deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1740 deviceUri.c_str(), deviceLocation.c_str(), userData);
1741 DeviceCb(deviceClass.c_str(), deviceId.c_str(), nullptr, deviceMakeAndModel.c_str(),
1742 deviceUri.c_str(), deviceLocation.c_str(), userData);
1743 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), nullptr,
1744 deviceUri.c_str(), deviceLocation.c_str(), userData);
1745 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1746 nullptr, deviceLocation.c_str(), userData);
1747 // Assert
1748 auto usbPrinters = GetUsbPrinters();
1749 EXPECT_EQ(usbPrinters.size(), 0);
1750 }
1751
1752 /**
1753 * @tc.name: PrintCupsClientTest_0091
1754 * @tc.desc: DeviceCb_Serial
1755 * @tc.type: FUNC
1756 * @tc.require:
1757 */
1758 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0091, TestSize.Level1)
1759 {
1760 // Arrange
1761 std::string deviceUri = "usb://printer_serial=123&111";
1762 std::string deviceClass = "printer";
1763 std::string deviceId = "model123";
1764 std::string deviceInfo = "model123";
1765 std::string deviceMakeAndModel = "model123";
1766 std::string deviceLocation = "1234-";
1767 void *userData = nullptr;
1768 // Act
1769 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1770 deviceUri.c_str(), deviceLocation.c_str(), userData);
1771 deviceLocation = "1234-5678";
1772 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1773 deviceUri.c_str(), deviceLocation.c_str(), userData);
1774 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1775 deviceUri.c_str(), nullptr, userData);
1776 // Assert
1777 auto usbPrinters = GetUsbPrinters();
1778 EXPECT_EQ(usbPrinters.size(), 3);
1779 EXPECT_STREQ(usbPrinters[0].GetUri().c_str(), deviceUri.c_str());
1780 EXPECT_STREQ(usbPrinters[0].GetPrinterMake().c_str(), deviceMakeAndModel.c_str());
1781 EXPECT_STREQ(usbPrinters[0].GetPrinterId().c_str(), "USB-model123-123");
1782 ClearUsbPrinters();
1783 }
1784
1785 /**
1786 * @tc.name: PrintCupsClientTest_0092
1787 * @tc.desc: GetUsbPrinterSerial
1788 * @tc.type: FUNC
1789 * @tc.require:
1790 */
1791 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0092, TestSize.Level1)
1792 {
1793 std::string usb = "usb://";
1794 std::string serial = "serial=";
1795 std::string num = "11";
1796 std::string deviceUri = usb;
1797 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), "");
1798 deviceUri = usb + serial;
1799 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), "");
1800 deviceUri = usb + serial + num;
1801 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), num.c_str());
1802 deviceUri = usb + serial + num + "&postfix";
1803 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), num.c_str());
1804 deviceUri = usb + serial + "1234567890" + "&postfix";
1805 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), "567890");
1806 }
1807 } // namespace Print
1808 } // namespace OHOS