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
58 static const std::string TEST_SERVICE_JOB_ID = "test_id";
59 static const std::string PRINTER_URI = "test_printer_uri";
60 static const std::string PRINTER_PRINTER_NAME = "test_printer_name";
61 static const std::string PRINTER_PRINTER_ID = "test_printer_id";
62 static const std::string JOB_USER_NAME = "test_user";
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, 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_NeedRename, 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_NeedRename, 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, AddCupsPrintJob_ShouldAddFailed_WhenCorrectPrintJob, TestSize.Level1)
275 {
276 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
277 PrintJob testJob;
278 printCupsClient->AddCupsPrintJob(testJob, JOB_USER_NAME);
279 EXPECT_EQ(printCupsClient->currentJob_, nullptr);
280 }
281
282 /**
283 * @tc.name: PrintCupsClientTest_0014
284 * @tc.desc: AddCupsPrintJob
285 * @tc.type: FUNC
286 * @tc.require:
287 */
288 HWTEST_F(PrintCupsClientTest, AddCupsPrintJob_ShouldAddSucceed_WhenNormalPrintJob, TestSize.Level0)
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, JOB_USER_NAME);
304 EXPECT_EQ(printCupsClient->currentJob_->printerId, "printid-1234");
305 }
306
307 /**
308 * @tc.name: PrintCupsClientTest_0015
309 * @tc.desc: StartNextJob
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(PrintCupsClientTest, StartNextJob_DoNothing_When_NullInQueue, TestSize.Level0)
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 EXPECT_EQ(printCupsClient->jobQueue_.size(), 0);
320 }
321
322 /**
323 * @tc.name: PrintCupsClientTest_0016
324 * @tc.desc: StartNextJob
325 * @tc.type: FUNC
326 * @tc.require:
327 */
328 HWTEST_F(PrintCupsClientTest, StartNextJob_Succeed_When_OnePrintJobInQueue, TestSize.Level1)
329 {
330 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
331 PrintJob testJob;
332 testJob.SetJobId(GetDefaultJobId());
333 std::vector<uint32_t> files = {1};
334 testJob.SetFdList(files);
335 OHOS::Print::PrintPageSize pageSize;
336 pageSize.SetId("pgid-1234");
337 testJob.SetPageSize(pageSize);
338 testJob.SetPrinterId("printid-1234");
339 testJob.SetOption(JOB_OPTIONS);
340 JobParameters *jobParams = printCupsClient->BuildJobParameters(testJob, JOB_USER_NAME);
341 printCupsClient->jobQueue_.push_back(jobParams);
342 EXPECT_EQ(printCupsClient->jobQueue_.size(), 1);
343 printCupsClient->toCups_ = false;
344 printCupsClient->StartNextJob();
345 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
346 EXPECT_EQ(printCupsClient->jobQueue_.size(), 0);
347 }
348
349 /**
350 * @tc.name: PrintCupsClientTest_0018
351 * @tc.desc: StartNextJob
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(PrintCupsClientTest, StartNextJob_ClearQueue_When_NullptrPrintJobInQueue, TestSize.Level0)
356 {
357 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
358 JobParameters *jobParams = nullptr;
359 printCupsClient->jobQueue_.push_back(jobParams);
360 EXPECT_EQ(printCupsClient->jobQueue_.size(), 1);
361 printCupsClient->toCups_ = false;
362 printCupsClient->StartNextJob();
363 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
364 EXPECT_EQ(printCupsClient->jobQueue_.size(), 0);
365 }
366
367 /**
368 * @tc.name: PrintCupsClientTest_0019
369 * @tc.desc: JobCompleteCallback
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0019_NeedRename, TestSize.Level1)
374 {
375 auto printCupsClient = std::make_shared<OHOS::Print::PrintCupsClient>();
376 PrintJob testJob;
377 testJob.SetJobId(GetDefaultJobId());
378 std::vector<uint32_t> files = {1};
379 testJob.SetFdList(files);
380 OHOS::Print::PrintPageSize pageSize;
381 pageSize.SetId("pgid-1234");
382 testJob.SetPageSize(pageSize);
383 testJob.SetPrinterId("printid-1234");
384 testJob.SetOption(JOB_OPTIONS);
385 JobParameters *jobParams = printCupsClient->BuildJobParameters(testJob, JOB_USER_NAME);
386 printCupsClient->JobSentCallback(); // currentJob_ is null, do nothing
387 printCupsClient->currentJob_ = jobParams;
388 printCupsClient->JobSentCallback(); // clear currentJob_
389 EXPECT_EQ(printCupsClient->currentJob_, nullptr);
390 std::this_thread::sleep_for(std::chrono::milliseconds(2000));
391 }
392
393 /**
394 * @tc.name: PrintCupsClientTest_0020
395 * @tc.desc: FillBorderlessOptions
396 * @tc.type: FUNC
397 * @tc.require:
398 */
399 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0020_NeedRename, TestSize.Level1)
400 {
401 OHOS::Print::PrintCupsClient printCupsClient;
402 int numOptions = 0;
403 cups_option_t *options = nullptr;
404 EXPECT_EQ(printCupsClient.FillBorderlessOptions(nullptr, numOptions, &options), 0);
405 EXPECT_EQ(printCupsClient.FillJobOptions(nullptr, numOptions, &options), 0);
406 }
407 /**
408 * @tc.name: PrintCupsClientTest_0021
409 * @tc.desc: FillBorderlessOptions
410 * @tc.type: FUNC
411 * @tc.require:
412 */
413 HWTEST_F(PrintCupsClientTest, FillThreeOptions_When_SetBorderless, TestSize.Level1)
414 {
415 OHOS::Print::PrintCupsClient printCupsClient;
416 PrintJob testJob;
417 testJob.SetJobId(GetDefaultJobId());
418 std::vector<uint32_t> files = {1};
419 testJob.SetFdList(files);
420 OHOS::Print::PrintPageSize pageSize;
421 pageSize.SetId("pgid-1234");
422 testJob.SetPageSize(pageSize);
423 testJob.SetPrinterId("printid-1234");
424 testJob.SetOption(JOB_OPTIONS);
425 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
426 jobParams->borderless = 1;
427 jobParams->mediaSize = "";
428 jobParams->mediaType = "";
429 int numOptions = 0;
430 cups_option_t *options = nullptr;
431 EXPECT_EQ(printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options), 3);
432 delete jobParams;
433 delete options;
434 }
435
436 /**
437 * @tc.name: PrintCupsClientTest_0022
438 * @tc.desc: FillBorderlessOptions
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(PrintCupsClientTest, FillThreeOptions_When_SetNotBorderless, TestSize.Level1)
443 {
444 OHOS::Print::PrintCupsClient printCupsClient;
445 PrintJob testJob;
446 testJob.SetJobId(GetDefaultJobId());
447 std::vector<uint32_t> files = {1};
448 testJob.SetFdList(files);
449 OHOS::Print::PrintPageSize pageSize;
450 pageSize.SetId("pgid-1234");
451 testJob.SetPageSize(pageSize);
452 testJob.SetPrinterId("printid-1234");
453 testJob.SetOption(JOB_OPTIONS);
454 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
455 jobParams->mediaSize = "testMediaSize";
456 jobParams->mediaType = "testMediaType";
457 int numOptions = 0;
458 cups_option_t *options = nullptr;
459 EXPECT_EQ(printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options), 3);
460 delete jobParams;
461 delete options;
462 }
463
464 /**
465 * @tc.name: PrintCupsClientTest_0023
466 * @tc.desc: FillBorderlessOptions
467 * @tc.type: FUNC
468 * @tc.require:
469 */
470 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0023_NeedRename, TestSize.Level1)
471 {
472 OHOS::Print::PrintCupsClient printCupsClient;
473 PrintJob testJob;
474 testJob.SetJobId(GetDefaultJobId());
475 std::vector<uint32_t> files = {1};
476 testJob.SetFdList(files);
477 OHOS::Print::PrintPageSize pageSize;
478 pageSize.SetId("pgid-1234");
479 testJob.SetPageSize(pageSize);
480 testJob.SetPrinterId("printid-1234");
481 testJob.SetOption(JOB_OPTIONS);
482 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
483 jobParams->borderless = 0;
484 jobParams->mediaType = CUPS_MEDIA_TYPE_PHOTO_GLOSSY;
485 int numOptions = 0;
486 cups_option_t *options = nullptr;
487 int ret = printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options);
488 EXPECT_EQ(ret, 3);
489 delete jobParams;
490 delete options;
491 }
492
493 /**
494 * @tc.name: PrintCupsClientTest_0024
495 * @tc.desc: FillBorderlessOptions
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0024_NeedRename, TestSize.Level1)
500 {
501 OHOS::Print::PrintCupsClient printCupsClient;
502 PrintJob testJob;
503 testJob.SetJobId(GetDefaultJobId());
504 std::vector<uint32_t> files = {1};
505 testJob.SetFdList(files);
506 OHOS::Print::PrintPageSize pageSize;
507 pageSize.SetId("pgid-1234");
508 testJob.SetPageSize(pageSize);
509 testJob.SetPrinterId("printid-1234");
510 testJob.SetOption(JOB_OPTIONS);
511 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
512 jobParams->borderless = 1;
513 jobParams->mediaType = CUPS_MEDIA_TYPE_PHOTO_GLOSSY;
514 jobParams->mediaSize = CUPS_MEDIA_4X6;
515 int numOptions = 0;
516 cups_option_t *options = nullptr;
517 int ret = printCupsClient.FillBorderlessOptions(jobParams, numOptions, &options);
518 EXPECT_EQ(ret, 2);
519 delete jobParams;
520 delete options;
521 }
522
523 /**
524 * @tc.name: PrintCupsClientTest_0025
525 * @tc.desc: FillJobOptions
526 * @tc.type: FUNC
527 * @tc.require:
528 */
529 HWTEST_F(PrintCupsClientTest, FillJobOptions_SetNullValue_ReturnCorrectNumOptions, TestSize.Level1)
530 {
531 int num = 0;
532 cups_option_t *options = nullptr;
533 OHOS::Print::PrintCupsClient printCupsClient;
534 PrintJob jobInfo;
535 jobInfo.SetCopyNumber(2);
536 jobInfo.SetDuplexMode(1);
537 jobInfo.SetColorMode(0);
538 jobInfo.SetOption(JOB_OPTIONS);
539 JobParameters *jobParams = printCupsClient.BuildJobParameters(jobInfo, JOB_USER_NAME);
540 jobParams->printerId = "1";
541 jobParams->numCopies = 2;
542 jobParams->duplex = "";
543 jobParams->printQuality = "";
544 jobParams->color = "";
545 jobParams->isAutoRotate = true;
546 jobParams->isCollate = false;
547 jobParams->isReverse = false;
548 int ret = printCupsClient.FillJobOptions(jobParams, num, &options);
549 EXPECT_EQ(ret, 9);
550 delete jobParams;
551 delete options;
552 }
553
554 /**
555 * @tc.name: PrintCupsClientTest_0026
556 * @tc.desc: FillJobOptions
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(PrintCupsClientTest, FillJobOptions_SetTrueValue_ReturnCorrectNumOptions, TestSize.Level1)
561 {
562 int num = 0;
563 cups_option_t *options = nullptr;
564 OHOS::Print::PrintCupsClient printCupsClient;
565 PrintJob jobInfo;
566 jobInfo.SetCopyNumber(2);
567 jobInfo.SetDuplexMode(1);
568 jobInfo.SetColorMode(0);
569 jobInfo.SetOption(JOB_OPTIONS);
570 JobParameters *jobParams = printCupsClient.BuildJobParameters(jobInfo, JOB_USER_NAME);
571 jobParams->printerId = "1";
572 jobParams->numCopies = 0;
573 jobParams->duplex = "test_duplex";
574 jobParams->printQuality = "test_printQuality";
575 jobParams->color = "test_color";
576 jobParams->borderless = 1;
577 jobParams->mediaType = CUPS_MEDIA_TYPE_PHOTO_GLOSSY;
578 jobParams->mediaSize = CUPS_MEDIA_4X6;
579 jobParams->isCollate = true;
580 jobParams->isReverse = true;
581 int ret = printCupsClient.FillJobOptions(jobParams, num, &options);
582 EXPECT_EQ(ret, 8);
583 delete jobParams;
584 delete options;
585 }
586
587 /**
588 * @tc.name: PrintCupsClientTest_0027
589 * @tc.desc: QueryAddedPrinterList
590 * @tc.type: FUNC
591 * @tc.require:
592 */
593 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0027_NeedRename, TestSize.Level1)
594 {
595 OHOS::Print::PrintCupsClient printCupsClient;
596 std::vector<std::string> printerNameList;
597 printerNameList.push_back("testPrinterName");
598 printCupsClient.StopCupsdService();
599 EXPECT_EQ(printCupsClient.QueryAddedPrinterList(printerNameList), E_PRINT_NONE);
600 }
601
602 /**
603 * @tc.name: PrintCupsClientTest_0028
604 * @tc.desc: QueryAddedPrinterList
605 * @tc.type: FUNC
606 * @tc.require:
607 */
608 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0028_NeedRename, TestSize.Level1)
609 {
610 OHOS::Print::PrintCupsClient printCupsClient;
611 std::vector<std::string> printerNameList;
612 printerNameList.push_back("testPrinterName");
613 printCupsClient.StartCupsdService();
614 EXPECT_EQ(printCupsClient.QueryAddedPrinterList(printerNameList), E_PRINT_NONE);
615 }
616
617 /**
618 * @tc.name: PrintCupsClientTest_0030
619 * @tc.desc: GetPPDFile
620 * @tc.type: FUNC
621 * @tc.require:
622 */
623 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0030_NeedRename, TestSize.Level1)
624 {
625 OHOS::Print::PrintCupsClient printCupsClient;
626 std::string printerName = "testPrinterName";
627 printCupsClient.StopCupsdService();
628 ppd_file_t *ppd = printCupsClient.GetPPDFile(printerName);
629 EXPECT_EQ(ppd, nullptr);
630 }
631
632 /**
633 * @tc.name: PrintCupsClientTest_0031
634 * @tc.desc: GetPPDFile
635 * @tc.type: FUNC
636 * @tc.require:
637 */
638 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0031_NeedRename, TestSize.Level1)
639 {
640 OHOS::Print::PrintCupsClient printCupsClient;
641 std::string printerName = "testPrinterName";
642 EXPECT_EQ(printCupsClient.StartCupsdService(), E_PRINT_NONE);
643 printCupsClient.GetPPDFile(printerName);
644 }
645
646 /**
647 * @tc.name: PrintCupsClientTest_0032
648 * @tc.desc: QueryPrinterAttrList
649 * @tc.type: FUNC
650 * @tc.require:
651 */
652 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0032_NeedRename, TestSize.Level1)
653 {
654 OHOS::Print::PrintCupsClient printCupsClient;
655 std::string printerName = "testPrinterName";
656 std::vector<std::string> keyList;
657 std::vector<std::string> valueList;
658 EXPECT_EQ(printCupsClient.QueryPrinterAttrList(printerName, keyList, valueList), E_PRINT_SERVER_FAILURE);
659 }
660
661 /**
662 * @tc.name: PrintCupsClientTest_0033
663 * @tc.desc: QueryPrinterInfoByPrinterId
664 * @tc.type: FUNC
665 * @tc.require:
666 */
667 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0033_NeedRename, TestSize.Level1)
668 {
669 OHOS::Print::PrintCupsClient printCupsClient;
670 std::string printerId = "testPrinterId";
671 PrinterInfo info;
672 info.SetPrinterName("testPrinterName");
673 EXPECT_EQ(printCupsClient.QueryPrinterInfoByPrinterId(printerId, info), E_PRINT_SERVER_FAILURE);
674 }
675
676 /**
677 * @tc.name: PrintCupsClientTest_0034
678 * @tc.desc: CheckPrinterMakeModel
679 * @tc.type: FUNC
680 * @tc.require:
681 */
682 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0034_NeedRename, TestSize.Level1)
683 {
684 OHOS::Print::PrintCupsClient printCupsClient;
685 JobParameters *jobParams = nullptr;
686 bool driverMissing = false;
687 bool ret = printCupsClient.CheckPrinterMakeModel(jobParams, driverMissing);
688 EXPECT_EQ(ret, false);
689 }
690
691 /**
692 * @tc.name: PrintCupsClientTest_0036
693 * @tc.desc: VerifyPrintJob
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0036_NeedRename, TestSize.Level1)
698 {
699 OHOS::Print::PrintCupsClient printCupsClient;
700 JobParameters *jobParams = nullptr;
701 int num = 0;
702 uint32_t jobId = 1;
703 cups_option_t *options = nullptr;
704 http_t *http = nullptr;
705 bool ret = printCupsClient.VerifyPrintJob(jobParams, num, jobId, options, http);
706 EXPECT_EQ(ret, false);
707 delete jobParams;
708 delete options;
709 delete http;
710 }
711
712 /**
713 * @tc.name: PrintCupsClientTest_0039
714 * @tc.desc: UpdatePrintJobStateInJobParams
715 * @tc.type: FUNC
716 * @tc.require:
717 */
718 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0039_NeedRename, TestSize.Level1)
719 {
720 OHOS::Print::PrintCupsClient printCupsClient;
721 PrintJob testJob;
722 testJob.SetJobId(GetDefaultJobId());
723 std::vector<uint32_t> files = {1};
724 testJob.SetFdList(files);
725 OHOS::Print::PrintPageSize pageSize;
726 pageSize.SetId("pgid-1234");
727 testJob.SetPageSize(pageSize);
728 testJob.SetPrinterId("printid-1234");
729 testJob.SetOption(JOB_OPTIONS);
730 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
731 EXPECT_NE(jobParams, nullptr);
732 EXPECT_NE(jobParams->serviceAbility, nullptr);
733
734 uint32_t state = PRINT_JOB_BLOCKED;
735 uint32_t subState = PRINT_JOB_BLOCKED_UNKNOWN;
736 printCupsClient.UpdatePrintJobStateInJobParams(jobParams, state, subState);
737
738 auto jobId = jobParams->serviceJobId;
739 auto userData = jobParams->serviceAbility->GetUserDataByJobId(jobId);
740 EXPECT_EQ(userData, nullptr);
741 delete jobParams;
742 }
743
744 /**
745 * @tc.name: PrintCupsClientTest_0042
746 * @tc.desc: UpdateJobStatus
747 * @tc.type: FUNC
748 * @tc.require:
749 */
750 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0042_NeedRename, TestSize.Level1)
751 {
752 OHOS::Print::PrintCupsClient printCupsClient;
753 EXPECT_FALSE(printCupsClient.CheckPrinterDriverExist(std::string()));
754 EXPECT_TRUE(printCupsClient.CheckPrinterDriverExist(DEFAULT_MAKE_MODEL));
755 EXPECT_TRUE(printCupsClient.CheckPrinterDriverExist(BSUNI_PPD_NAME));
756 EXPECT_FALSE(printCupsClient.CheckPrinterDriverExist(REMOTE_PRINTER_MAKE_MODEL));
757 }
758
759 /**
760 * @tc.name: PrintCupsClientTest_0043
761 * @tc.desc: UpdateJobStatus
762 * @tc.type: FUNC
763 * @tc.require:
764 */
765 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0043_NeedRename, TestSize.Level1)
766 {
767 OHOS::Print::PrintCupsClient printCupsClient;
768 printCupsClient.StartMonitor();
769 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
770 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
771 printCupsClient.StartMonitor();
772 EXPECT_EQ(printCupsClient.jobMonitorList_.size(), 0);
773 }
774
775 /**
776 * @tc.name: PrintCupsClientTest_0047
777 * @tc.desc: JobStatusCallback
778 * @tc.type: FUNC
779 * @tc.require:
780 */
781 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0047_NeedRename, TestSize.Level1)
782 {
783 OHOS::Print::PrintCupsClient printCupsClient;
784 printCupsClient.IsPrinterStopped(nullptr);
785 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
786 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
787 EXPECT_FALSE(printCupsClient.IsPrinterStopped(param));
788 }
789
790 /**
791 * @tc.name: PrintCupsClientTest_0048
792 * @tc.desc: JobStatusCallback
793 * @tc.type: FUNC
794 * @tc.require:
795 */
796 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0048_NeedRename, TestSize.Level1)
797 {
798 OHOS::Print::PrintCupsClient printCupsClient;
799 printCupsClient.IfContinueToHandleJobState(nullptr);
800 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
801 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
802 EXPECT_TRUE(printCupsClient.IfContinueToHandleJobState(param));
803 param->isCanceled = true;
804 EXPECT_FALSE(printCupsClient.IfContinueToHandleJobState(param));
805 }
806
807 /**
808 * @tc.name: PrintCupsClientTest_0049
809 * @tc.desc: JobStatusCallback
810 * @tc.type: FUNC
811 * @tc.require:
812 */
813 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0049_NeedRename, TestSize.Level1)
814 {
815 OHOS::Print::PrintCupsClient printCupsClient;
816 printCupsClient.JobStatusCallback(nullptr);
817 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
818 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
819 param->substate = 0;
820 param->job_state = IPP_JOB_COMPLETED;
821 param->isBlock = false;
822 param->timesOfSameState = 0;
823 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
824 param->isBlock = true;
825 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
826 param->timesOfSameState = STATE_UPDATE_STEP;
827 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
828 }
829
830 /**
831 * @tc.name: PrintCupsClientTest_0050
832 * @tc.desc: JobStatusCallback
833 * @tc.type: FUNC
834 * @tc.require:
835 */
836 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0050_NeedRename, TestSize.Level1)
837 {
838 OHOS::Print::PrintCupsClient printCupsClient;
839 printCupsClient.JobStatusCallback(nullptr);
840 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
841 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
842 param->substate = 0;
843 param->job_state = IPP_JOB_PROCESSING;
844 param->isBlock = false;
845 param->timesOfSameState = 0;
846 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
847 param->isBlock = true;
848 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
849 param->timesOfSameState = STATE_UPDATE_STEP;
850 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
851 }
852
853 /**
854 * @tc.name: PrintCupsClientTest_0051
855 * @tc.desc: JobStatusCallback
856 * @tc.type: FUNC
857 * @tc.require:
858 */
859 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0051_NeedRename, TestSize.Level1)
860 {
861 OHOS::Print::PrintCupsClient printCupsClient;
862 printCupsClient.JobStatusCallback(nullptr);
863 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
864 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
865 param->substate = 0;
866 param->job_state = IPP_JOB_CANCELED;
867 param->isBlock = false;
868 param->timesOfSameState = 0;
869 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
870 param->isBlock = true;
871 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
872 param->timesOfSameState = STATE_UPDATE_STEP;
873 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
874 }
875
876 /**
877 * @tc.name: PrintCupsClientTest_0052
878 * @tc.desc: JobStatusCallback
879 * @tc.type: FUNC
880 * @tc.require:
881 */
882 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0052_NeedRename, TestSize.Level1)
883 {
884 OHOS::Print::PrintCupsClient printCupsClient;
885 printCupsClient.JobStatusCallback(nullptr);
886 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
887 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
888 param->substate = 0;
889 param->job_state = IPP_JOB_ABORTED;
890 param->isBlock = false;
891 param->timesOfSameState = 0;
892 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
893 param->isBlock = true;
894 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
895 param->timesOfSameState = STATE_UPDATE_STEP;
896 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
897 }
898
899 /**
900 * @tc.name: PrintCupsClientTest_0053
901 * @tc.desc: ReportBlockedReason
902 * @tc.type: FUNC
903 * @tc.require:
904 */
905 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0053_NeedRename, TestSize.Level1)
906 {
907 OHOS::Print::PrintCupsClient printCupsClient;
908 printCupsClient.JobStatusCallback(nullptr);
909 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
910 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
911 param->substate = 0;
912 param->job_state = IPP_JOB_STOPPED;
913 param->isBlock = false;
914 param->timesOfSameState = 0;
915 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
916 param->isBlock = true;
917 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
918 param->timesOfSameState = STATE_UPDATE_STEP;
919 EXPECT_FALSE(printCupsClient.JobStatusCallback(param));
920 }
921
922 /**
923 * @tc.name: PrintCupsClientTest_0054
924 * @tc.desc: ReportBlockedReason
925 * @tc.type: FUNC
926 * @tc.require:
927 */
928 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0054_NeedRename, TestSize.Level1)
929 {
930 OHOS::Print::PrintCupsClient printCupsClient;
931 printCupsClient.JobStatusCallback(nullptr);
932 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
933 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
934 param->substate = 0;
935 param->job_state = IPP_JOB_PENDING;
936 param->isBlock = false;
937 param->timesOfSameState = 0;
938 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
939 param->isBlock = true;
940 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
941 param->timesOfSameState = STATE_UPDATE_STEP;
942 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
943 char jobState[] = "printer-stopped";
944 strlcpy(param->job_state_reasons, jobState, sizeof(param->job_state_reasons));
945 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
946 }
947
948 /**
949 * @tc.name: PrintCupsClientTest_0055
950 * @tc.desc: ReportBlockedReason
951 * @tc.type: FUNC
952 * @tc.require:
953 */
954 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0055_NeedRename, TestSize.Level1)
955 {
956 OHOS::Print::PrintCupsClient printCupsClient;
957 printCupsClient.JobStatusCallback(nullptr);
958 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
959 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
960 param->substate = 0;
961 param->job_state = IPP_JOB_HELD;
962 param->isBlock = false;
963 param->timesOfSameState = 0;
964 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
965 param->isBlock = true;
966 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
967 param->timesOfSameState = STATE_UPDATE_STEP;
968 EXPECT_TRUE(printCupsClient.JobStatusCallback(param));
969 }
970
971 /**
972 * @tc.name: PrintCupsClientTest_0056
973 * @tc.desc: QueryJobState
974 * @tc.type: FUNC
975 * @tc.require:
976 */
977 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0056_NeedRename, TestSize.Level1)
978 {
979 OHOS::Print::PrintCupsClient printCupsClient;
980 printCupsClient.ParseStateReasons(nullptr);
981 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
982 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
983 param->isPrinterStopped = false;
984 printCupsClient.ParseStateReasons(param);
985 EXPECT_EQ(param->substate, 0);
986 param->isPrinterStopped = true;
987 printCupsClient.ParseStateReasons(param);
988 EXPECT_EQ(param->substate, 99);
989 }
990
991 /**
992 * @tc.name: PrintCupsClientTest_0057
993 * @tc.desc: QueryJobState
994 * @tc.type: FUNC
995 * @tc.require:
996 */
997 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0057_NeedRename, TestSize.Level1)
998 {
999 OHOS::Print::PrintCupsClient printCupsClient;
1000 printCupsClient.GetBlockedAndUpdateSubstate(nullptr, STATE_POLICY_STANDARD,
1001 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED);
1002 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1003 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1004 param->substate = 0;
1005 param->isBlock = false;
1006 param->timesOfSameState = 0;
1007 std::string reason = "media-jam-error";
1008 reason.copy(param->job_printer_state_reasons, reason.length() + 1);
1009 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_STANDARD,
1010 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1011 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_BLOCK,
1012 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1013 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_HINT,
1014 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1015 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1016 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1017 param->timesOfSameState = STATE_UPDATE_STEP;
1018 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1019 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1020 }
1021
1022 /**
1023 * @tc.name: PrintCupsClientTest_0058
1024 * @tc.desc: QueryJobState
1025 * @tc.type: FUNC
1026 * @tc.require:
1027 */
1028 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0058_NeedRename, TestSize.Level1)
1029 {
1030 OHOS::Print::PrintCupsClient printCupsClient;
1031 printCupsClient.GetBlockedAndUpdateSubstate(nullptr, STATE_POLICY_STANDARD,
1032 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED);
1033 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1034 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1035 param->substate = 0;
1036 param->isBlock = false;
1037 param->timesOfSameState = 0;
1038 std::string reason = "media-jam-warning";
1039 reason.copy(param->job_printer_state_reasons, reason.length() + 1);
1040 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_STANDARD,
1041 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1042 EXPECT_TRUE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_BLOCK,
1043 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1044 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_HINT,
1045 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1046 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1047 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1048 param->timesOfSameState = STATE_UPDATE_STEP;
1049 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1050 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1051 }
1052
1053 /**
1054 * @tc.name: PrintCupsClientTest_0059
1055 * @tc.desc: CancelCupsJob
1056 * @tc.type: FUNC
1057 * @tc.require:
1058 */
1059 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0059_NeedRename, TestSize.Level1)
1060 {
1061 OHOS::Print::PrintCupsClient printCupsClient;
1062 int num = printCupsClient.jobQueue_.size();
1063 printCupsClient.CancelCupsJob(GetDefaultJobId());
1064 if (num > 0) {
1065 num = num - 1;
1066 }
1067 EXPECT_EQ(printCupsClient.jobQueue_.size(), num);
1068 }
1069
1070 /**
1071 * @tc.name: PrintCupsClientTest_0060
1072 * @tc.desc: CancelCupsJob
1073 * @tc.type: FUNC
1074 * @tc.require:
1075 */
1076 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0060_NeedRename, TestSize.Level1)
1077 {
1078 OHOS::Print::PrintCupsClient printCupsClient;
1079 std::string serviceJobId = "0";
1080 PrintJob testJob;
1081 testJob.SetJobId(GetDefaultJobId());
1082 std::vector<uint32_t> files = {1};
1083 testJob.SetFdList(files);
1084 OHOS::Print::PrintPageSize pageSize;
1085 pageSize.SetId("pgid-1234");
1086 testJob.SetPageSize(pageSize);
1087 testJob.SetPrinterId("printid-1234");
1088 testJob.SetOption(JOB_OPTIONS);
1089 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1090 EXPECT_EQ(jobParams->jobOriginatingUserName, JOB_USER_NAME);
1091 printCupsClient.jobQueue_.push_back(jobParams);
1092 PRINT_HILOGI("CancelCupsJob(): printCupsClient.jobQueue_.size(): %{public}u", printCupsClient.jobQueue_.size());
1093 printCupsClient.CancelCupsJob(serviceJobId);
1094 }
1095
1096 /**
1097 * @tc.name: PrintCupsClientTest_0061
1098 * @tc.desc: CancelCupsJob
1099 * @tc.type: FUNC
1100 * @tc.require:
1101 */
1102 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0061_NeedRename, TestSize.Level1)
1103 {
1104 OHOS::Print::PrintCupsClient printCupsClient;
1105 std::string serviceJobId = "1";
1106 PrintJob testJob;
1107 testJob.SetJobId(GetDefaultJobId());
1108 std::vector<uint32_t> files = {1};
1109 testJob.SetFdList(files);
1110 OHOS::Print::PrintPageSize pageSize;
1111 pageSize.SetId("pgid-1234");
1112 testJob.SetPageSize(pageSize);
1113 testJob.SetPrinterId("printid-1234");
1114 testJob.SetOption(JOB_OPTIONS);
1115 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1116 EXPECT_EQ(jobParams->jobOriginatingUserName, JOB_USER_NAME);
1117 printCupsClient.jobQueue_.push_back(jobParams);
1118 printCupsClient.CancelCupsJob(serviceJobId);
1119 }
1120
1121 /**
1122 * @tc.name: PrintCupsClientTest_0062
1123 * @tc.desc: CancelCupsJob
1124 * @tc.type: FUNC
1125 * @tc.require:
1126 */
1127 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0062_NeedRename, TestSize.Level1)
1128 {
1129 OHOS::Print::PrintCupsClient printCupsClient;
1130 std::string serviceJobId = TEST_SERVICE_JOB_ID;
1131 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1132 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1133 printCupsClient.jobMonitorList_ = std::vector<std::shared_ptr<JobMonitorParam>> (1, param);
1134 printCupsClient.CancelCupsJob("invalidId");
1135 EXPECT_FALSE(param->isCanceled);
1136 printCupsClient.CancelCupsJob(TEST_SERVICE_JOB_ID);
1137 EXPECT_TRUE(param->isCanceled);
1138 }
1139
1140 /**
1141 * @tc.name: PrintCupsClientTest_0063
1142 * @tc.desc: QueryJobState
1143 * @tc.type: FUNC
1144 * @tc.require:
1145 */
1146 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0063_NeedRename, TestSize.Level1)
1147 {
1148 OHOS::Print::PrintCupsClient printCupsClient;
1149 printCupsClient.GetBlockedAndUpdateSubstate(nullptr, STATE_POLICY_STANDARD,
1150 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED);
1151 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1152 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1153 param->substate = 0;
1154 param->isBlock = false;
1155 param->timesOfSameState = 0;
1156 std::string reason = "null";
1157 reason.copy(param->job_printer_state_reasons, reason.length() + 1);
1158 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_STANDARD,
1159 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1160 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_BLOCK,
1161 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1162 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_HINT,
1163 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1164 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1165 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1166 param->timesOfSameState = STATE_UPDATE_STEP;
1167 EXPECT_FALSE(printCupsClient.GetBlockedAndUpdateSubstate(param, STATE_POLICY_DELAY,
1168 PRINTER_STATE_MEDIA_JAM, PRINT_JOB_BLOCKED_JAMMED));
1169 }
1170
1171 /**
1172 * @tc.name: PrintCupsClientTest_0066
1173 * @tc.desc: BuildJobParameters
1174 * @tc.type: FUNC
1175 * @tc.require:
1176 */
1177 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0066_NeedRename, TestSize.Level1)
1178 {
1179 OHOS::Print::PrintCupsClient printCupsClient;
1180 PrintJob testJob;
1181 testJob.SetJobId(GetDefaultJobId());
1182 std::vector<uint32_t> files = {1};
1183 testJob.SetFdList(files);
1184 OHOS::Print::PrintPageSize pageSize;
1185 pageSize.SetId("pgid-1234");
1186 testJob.SetPageSize(pageSize);
1187 testJob.SetPrinterId("printid-1234");
1188 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1189 EXPECT_EQ(jobParams, nullptr);
1190
1191 testJob.SetOption("test");
1192 printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1193 EXPECT_EQ(jobParams, nullptr);
1194 delete jobParams;
1195 }
1196
1197 /**
1198 * @tc.name: PrintCupsClientTest_0067
1199 * @tc.desc: BuildJobParameters
1200 * @tc.type: FUNC
1201 * @tc.require:
1202 */
1203 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0067_NeedRename, TestSize.Level1)
1204 {
1205 OHOS::Print::PrintCupsClient printCupsClient;
1206 PrintJob testJob;
1207 testJob.SetJobId(GetDefaultJobId());
1208 std::vector<uint32_t> files = {1};
1209 testJob.SetFdList(files);
1210 OHOS::Print::PrintPageSize pageSize;
1211 pageSize.SetId("pgid-1234");
1212 testJob.SetPageSize(pageSize);
1213 testJob.SetPrinterId("printid-1234");
1214 testJob.SetIsLandscape(true);
1215 testJob.SetOption(R"({"key": "value"})");
1216 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1217 EXPECT_EQ(jobParams, nullptr);
1218
1219 Json::Value optionJson;
1220 PrintJsonUtil::Parse(testJob.GetOption(), optionJson);
1221 optionJson["printerUri"] = "ipp://192.168.0.1:111/ipp/print";
1222 optionJson["printerName"] = "printer1";
1223 optionJson["documentFormat"] = "application/pdf";
1224 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1225 jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1226 EXPECT_EQ(jobParams->printerUri, optionJson["printerUri"].asString());
1227 EXPECT_EQ(jobParams->printerName, PrintUtil::StandardizePrinterName(optionJson["printerName"].asString()));
1228 EXPECT_EQ(jobParams->documentFormat, optionJson["documentFormat"].asString());
1229
1230 optionJson["cupsOptions"] = "testCupsOptions";
1231 optionJson["printQuality"] = "printQuality";
1232 optionJson["jobName"] = "jobName";
1233 optionJson["mediaType"] = "mediaType";
1234 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1235 jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1236 EXPECT_EQ(jobParams->printerAttrsOptionCupsOption, optionJson["cupsOptions"].asString());
1237 EXPECT_EQ(jobParams->printQuality, optionJson["printQuality"].asString());
1238 EXPECT_EQ(jobParams->jobName, optionJson["jobName"].asString());
1239 EXPECT_EQ(jobParams->mediaType, optionJson["mediaType"].asString());
1240
1241 optionJson["printQuality"] = 1;
1242 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1243 jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1244 EXPECT_EQ(jobParams->printQuality, CUPS_PRINT_QUALITY_NORMAL);
1245
1246 EXPECT_EQ(jobParams->isAutoRotate, true); // default true
1247 optionJson["isAutoRotate"] = false;
1248 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1249 jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1250 EXPECT_EQ(jobParams->isAutoRotate, optionJson["isAutoRotate"].asBool());
1251 }
1252
1253 /**
1254 * @tc.name: PrintCupsClientTest_0068
1255 * @tc.desc: DumpJobParameters
1256 * @tc.type: FUNC
1257 * @tc.require:
1258 */
1259 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0068_NeedRename, TestSize.Level1)
1260 {
1261 OHOS::Print::PrintCupsClient printCupsClient;
1262 PrintJob testJob;
1263 testJob.SetJobId(GetDefaultJobId());
1264 std::vector<uint32_t> files = {1};
1265 testJob.SetFdList(files);
1266 testJob.SetColorMode(1);
1267 testJob.SetCopyNumber(1);
1268 testJob.SetDuplexMode(0);
1269 OHOS::Print::PrintPageSize pageSize;
1270 pageSize.SetId("pgid-1234");
1271 testJob.SetPageSize(pageSize);
1272 testJob.SetPrinterId("printid-1234");
1273 testJob.SetOption(JOB_OPTIONS);
1274 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1275 std::string option = testJob.GetOption();
1276 Json::Value optionJson;
1277 PrintJsonUtil::Parse(option, optionJson);
1278 EXPECT_EQ(jobParams->jobName, optionJson["jobName"].asString());
1279 EXPECT_EQ(jobParams->mediaType, optionJson["mediaType"].asString());
1280 EXPECT_EQ(jobParams->printQuality, optionJson["printQuality"].asString());
1281 EXPECT_EQ(jobParams->printerName, optionJson["printerName"].asString());
1282 EXPECT_EQ(jobParams->printerUri, optionJson["printerUri"].asString());
1283 EXPECT_EQ(jobParams->documentFormat, optionJson["documentFormat"].asString());
1284 EXPECT_EQ(jobParams->isAutoRotate, optionJson["isAutoRotate"].asBool());
1285 printCupsClient.DumpJobParameters(jobParams);
1286 delete jobParams;
1287 }
1288
1289 /**
1290 * @tc.name: PrintCupsClientTest_0069
1291 * @tc.desc: GetMedieSize
1292 * @tc.type: FUNC
1293 * @tc.require:
1294 */
1295 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0069_NeedRename, TestSize.Level1)
1296 {
1297 OHOS::Print::PrintCupsClient printCupsClient;
1298 PrintJob testJob;
1299 testJob.SetJobId(GetDefaultJobId());
1300 std::vector<uint32_t> files = {1};
1301 testJob.SetFdList(files);
1302 testJob.SetColorMode(1);
1303 testJob.SetCopyNumber(1);
1304 testJob.SetDuplexMode(0);
1305 OHOS::Print::PrintPageSize pageSize;
1306 pageSize.SetId("pgid-1234");
1307 testJob.SetPageSize(pageSize);
1308 testJob.SetPrinterId("printid-1234");
1309 testJob.SetOption(JOB_OPTIONS);
1310 std::string pageSizeName = printCupsClient.GetMedieSize(testJob);
1311 EXPECT_EQ("PrintPageSize", pageSizeName);
1312 }
1313
1314 /**
1315 * @tc.name: PrintCupsClientTest_0070
1316 * @tc.desc: GetDulpexString
1317 * @tc.type: FUNC
1318 * @tc.require:
1319 */
1320 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0070_NeedRename, TestSize.Level1)
1321 {
1322 OHOS::Print::PrintCupsClient printCupsClient;
1323 uint32_t duplexCode = 0;
1324 std::string ret0 = printCupsClient.GetDulpexString(duplexCode);
1325 EXPECT_EQ(ret0, CUPS_SIDES_ONE_SIDED);
1326
1327 duplexCode = 1;
1328 std::string ret1 = printCupsClient.GetDulpexString(duplexCode);
1329 EXPECT_EQ(ret1, CUPS_SIDES_TWO_SIDED_PORTRAIT);
1330
1331 duplexCode = 2;
1332 std::string ret2 = printCupsClient.GetDulpexString(duplexCode);
1333 EXPECT_EQ(ret2, CUPS_SIDES_TWO_SIDED_LANDSCAPE);
1334
1335 duplexCode = 3;
1336 std::string ret3 = printCupsClient.GetDulpexString(duplexCode);
1337 EXPECT_EQ(ret3, CUPS_SIDES_ONE_SIDED);
1338 }
1339
1340 /**
1341 * @tc.name: PrintCupsClientTest_0071
1342 * @tc.desc: GetColorString
1343 * @tc.type: FUNC
1344 * @tc.require:
1345 */
1346 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0071_NeedRename, TestSize.Level1)
1347 {
1348 OHOS::Print::PrintCupsClient printCupsClient;
1349 uint32_t colorCode = 0;
1350 std::string ret0 = printCupsClient.GetColorString(colorCode);
1351 EXPECT_EQ(ret0, CUPS_PRINT_COLOR_MODE_MONOCHROME);
1352
1353 colorCode = 1;
1354 std::string ret1 = printCupsClient.GetColorString(colorCode);
1355 EXPECT_EQ(ret1, CUPS_PRINT_COLOR_MODE_COLOR);
1356
1357 colorCode = 2;
1358 std::string ret2 = printCupsClient.GetColorString(colorCode);
1359 EXPECT_EQ(ret2, CUPS_PRINT_COLOR_MODE_AUTO);
1360 }
1361
1362 /**
1363 * @tc.name: PrintCupsClientTest_0073
1364 * @tc.desc: IsPrinterExist
1365 * @tc.type: FUNC
1366 * @tc.require:
1367 */
1368 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0073_NeedRename, TestSize.Level1)
1369 {
1370 OHOS::Print::PrintCupsClient printCupsClient;
1371 const char *printerUri = "ipp://192.168.186.1:631/ipp/print";
1372 const char *printerName = "DIRECT-PixLab_V1-0105";
1373 const char *ppdName = "DIRECT-PixLab_V1-0105.ppd";
1374 EXPECT_EQ(printCupsClient.IsPrinterExist(printerUri, printerName, ppdName), E_PRINT_NONE);
1375 }
1376
1377 /**
1378 * @tc.name: PrintCupsClientTest_0074
1379 * @tc.desc: ConvertInchTo100MM
1380 * @tc.type: FUNC
1381 * @tc.require:
1382 */
1383 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0074_NeedRename, TestSize.Level1)
1384 {
1385 OHOS::Print::PrintCupsClient printCupsClient;
1386 float num = 1000;
1387 float ret = printCupsClient.ConvertInchTo100MM(num);
1388 EXPECT_EQ(ret, 2540);
1389 }
1390
1391 /**
1392 * @tc.name: PrintCupsClientTest_0075
1393 * @tc.desc: IsIpConflict
1394 * @tc.type: FUNC
1395 * @tc.require:
1396 */
1397 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0075_NeedRename, TestSize.Level1)
1398 {
1399 OHOS::Print::PrintCupsClient printCupsClient;
1400 std::string printerId = "com.ohos.spooler:usb://DIRECT-PixLab_V1-1620";
1401 std::string nic = "";
1402 bool ret1 = printCupsClient.IsIpConflict(printerId, nic);
1403 EXPECT_EQ(ret1, false);
1404
1405 printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1406 bool ret2 = printCupsClient.IsIpConflict(printerId, nic);
1407 EXPECT_EQ(ret2, false);
1408 }
1409
1410 /**
1411 * @tc.name: PrintCupsClientTest_0077
1412 * @tc.desc: DiscoverUsbPrinters
1413 * @tc.type: FUNC
1414 * @tc.require:
1415 */
1416 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0077_NeedRename, TestSize.Level1)
1417 {
1418 OHOS::Print::PrintCupsClient printCupsClient;
1419 std::vector<PrinterInfo> printers;
1420 printCupsClient.DiscoverUsbPrinters(printers);
1421 EXPECT_EQ(printers.size(), 0);
1422 }
1423
1424 /**
1425 * @tc.name: PrintCupsClientTest_0078
1426 * @tc.desc: BuildJobParameters
1427 * @tc.type: FUNC
1428 * @tc.require:
1429 */
1430 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0078_NeedRename, TestSize.Level1)
1431 {
1432 OHOS::Print::PrintCupsClient printCupsClient;
1433 PrintJob testJob;
1434 testJob.SetJobId(GetDefaultJobId());
1435 std::vector<uint32_t> files = {1};
1436 testJob.SetFdList(files);
1437 OHOS::Print::PrintPageSize pageSize;
1438 pageSize.SetId("pgid-1234");
1439 testJob.SetPageSize(pageSize);
1440 testJob.SetPrinterId("printid-1234");
1441 testJob.SetOption(R"({"key": "value"})");
1442
1443 Json::Value optionJson;
1444 PrintJsonUtil::Parse(testJob.GetOption(), optionJson);
1445 optionJson["printerUri"] = 1;
1446 optionJson["printerName"] = "printer1";
1447 optionJson["documentFormat"] = "application/pdf";
1448 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1449 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1450 EXPECT_EQ(jobParams, nullptr);
1451
1452 optionJson["printerUri"] = "ipp://192.168.0.1:111/ipp/print";
1453 optionJson["printerName"] = 1;
1454 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1455 jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1456 EXPECT_EQ(jobParams, nullptr);
1457
1458 optionJson["printerName"] = "printer1";
1459 optionJson["documentFormat"] = 1;
1460 testJob.SetOption(PrintJsonUtil::WriteString(optionJson));
1461 jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1462 EXPECT_EQ(jobParams, nullptr);
1463 }
1464
1465 /**
1466 * @tc.name: PrintCupsClientTest_0079
1467 * @tc.desc: HandleFiles
1468 * @tc.type: FUNC
1469 * @tc.require:
1470 */
1471 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0079_NeedRename, TestSize.Level1)
1472 {
1473 OHOS::Print::PrintCupsClient printCupsClient;
1474 http_t *http = nullptr;
1475 JobParameters *jobParams = nullptr;
1476 int32_t numFiles = 1;
1477 int32_t jobId = 1;
1478 EXPECT_EQ(printCupsClient.HandleFiles(jobParams, numFiles, http, jobId), false);
1479 PrintJob testJob;
1480 testJob.SetJobId(GetDefaultJobId());
1481 std::vector<uint32_t> files = {1};
1482 testJob.SetFdList(files);
1483 testJob.SetColorMode(1);
1484 testJob.SetCopyNumber(1);
1485 testJob.SetDuplexMode(0);
1486 OHOS::Print::PrintPageSize pageSize;
1487 pageSize.SetId("pgid-1234");
1488 testJob.SetPageSize(pageSize);
1489 testJob.SetPrinterId("printid-1234");
1490 testJob.SetOption(JOB_OPTIONS);
1491 jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1492 delete http;
1493 delete jobParams;
1494 }
1495
1496 /**
1497 * @tc.name: PrintCupsClientTest_0081
1498 * @tc.desc: UpdateJobState
1499 * @tc.type: FUNC
1500 * @tc.require:
1501 */
1502 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0081_NeedRename, TestSize.Level1)
1503 {
1504 OHOS::Print::PrintCupsClient printCupsClient;
1505 EXPECT_FALSE(printCupsClient.UpdateJobState(nullptr, nullptr));
1506 auto param = std::make_shared<JobMonitorParam>(PrintServiceAbility::GetInstance(),
1507 TEST_SERVICE_JOB_ID, TEST_CUPS_JOB_ID, PRINTER_URI, PRINTER_PRINTER_NAME, PRINTER_PRINTER_ID, nullptr);
1508 EXPECT_FALSE(printCupsClient.UpdateJobState(param, nullptr));
1509 }
1510
1511 /**
1512 * @tc.name: PrintCupsClientTest_0082
1513 * @tc.desc: ResumePrinter
1514 * @tc.type: FUNC
1515 * @tc.require:
1516 */
1517 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0082_NeedRename, TestSize.Level1)
1518 {
1519 OHOS::Print::PrintCupsClient printCupsClient;
1520 std::string printerName = "testPrinterName";
1521 EXPECT_EQ(printCupsClient.ResumePrinter(printerName), false);
1522 printCupsClient.printAbility_ = nullptr;
1523 EXPECT_EQ(printCupsClient.ResumePrinter(printerName), false);
1524 }
1525
1526 /**
1527 * @tc.name: PrintCupsClientTest_0083
1528 * @tc.desc: FillLandscapeOptions
1529 * @tc.type: FUNC
1530 * @tc.require:
1531 */
1532 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0083_NeedRename, TestSize.Level1)
1533 {
1534 OHOS::Print::PrintCupsClient printCupsClient;
1535 PrintJob testJob;
1536 testJob.SetJobId(GetDefaultJobId());
1537 std::vector<uint32_t> files = {1};
1538 testJob.SetFdList(files);
1539 OHOS::Print::PrintPageSize pageSize;
1540 pageSize.SetId("pgid-1234");
1541 testJob.SetPageSize(pageSize);
1542 testJob.SetPrinterId("printid-1234");
1543 testJob.SetIsLandscape(true);
1544 testJob.SetOption(JOB_OPTIONS);
1545 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1546 jobParams->isAutoRotate = true;
1547 jobParams->isLandscape = true;
1548 int numOptions = 0;
1549 cups_option_t *options = nullptr;
1550 EXPECT_EQ(printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options), 0);
1551 delete jobParams;
1552 delete options;
1553 }
1554
1555 /**
1556 * @tc.name: PrintCupsClientTest_0084
1557 * @tc.desc: FillLandscapeOptions
1558 * @tc.type: FUNC
1559 * @tc.require:
1560 */
1561 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0084_NeedRename, TestSize.Level1)
1562 {
1563 OHOS::Print::PrintCupsClient printCupsClient;
1564 PrintJob testJob;
1565 testJob.SetJobId(GetDefaultJobId());
1566 std::vector<uint32_t> files = {1};
1567 testJob.SetFdList(files);
1568 OHOS::Print::PrintPageSize pageSize;
1569 pageSize.SetId("pgid-1234");
1570 testJob.SetPageSize(pageSize);
1571 testJob.SetPrinterId("printid-1234");
1572 testJob.SetIsLandscape(true);
1573 testJob.SetOption(JOB_OPTIONS);
1574 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1575 jobParams->isAutoRotate = true;
1576 jobParams->isLandscape = false;
1577 int numOptions = 0;
1578 cups_option_t *options = nullptr;
1579 EXPECT_EQ(printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options), 0);
1580 delete jobParams;
1581 delete options;
1582 }
1583
1584 /**
1585 * @tc.name: PrintCupsClientTest_0085
1586 * @tc.desc: FillLandscapeOptions
1587 * @tc.type: FUNC
1588 * @tc.require:
1589 */
1590 HWTEST_F(PrintCupsClientTest, FillTwoOptions_When_SetNotLandscape, TestSize.Level1)
1591 {
1592 OHOS::Print::PrintCupsClient printCupsClient;
1593 PrintJob testJob;
1594 testJob.SetJobId(GetDefaultJobId());
1595 std::vector<uint32_t> files = {1};
1596 testJob.SetFdList(files);
1597 OHOS::Print::PrintPageSize pageSize;
1598 pageSize.SetId("pgid-1234");
1599 testJob.SetPageSize(pageSize);
1600 testJob.SetPrinterId("printid-1234");
1601 testJob.SetIsLandscape(true);
1602 testJob.SetOption(JOB_OPTIONS);
1603 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1604 jobParams->isAutoRotate = false;
1605 jobParams->isLandscape = false;
1606 int numOptions = 0;
1607 cups_option_t *options = nullptr;
1608 EXPECT_EQ(printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options), 2);
1609 delete jobParams;
1610 delete options;
1611 }
1612
1613 /**
1614 * @tc.name: PrintCupsClientTest_0086
1615 * @tc.desc: FillLandscapeOptions
1616 * @tc.type: FUNC
1617 * @tc.require:
1618 */
1619 HWTEST_F(PrintCupsClientTest, FillTwoOptions_When_SetLandscape, TestSize.Level1)
1620 {
1621 OHOS::Print::PrintCupsClient printCupsClient;
1622 PrintJob testJob;
1623 testJob.SetJobId(GetDefaultJobId());
1624 std::vector<uint32_t> files = {1};
1625 testJob.SetFdList(files);
1626 OHOS::Print::PrintPageSize pageSize;
1627 pageSize.SetId("pgid-1234");
1628 testJob.SetPageSize(pageSize);
1629 testJob.SetPrinterId("printid-1234");
1630 testJob.SetIsLandscape(true);
1631 testJob.SetOption(JOB_OPTIONS);
1632 JobParameters *jobParams = printCupsClient.BuildJobParameters(testJob, JOB_USER_NAME);
1633 jobParams->isAutoRotate = false;
1634 jobParams->isLandscape = true;
1635 int numOptions = 0;
1636 cups_option_t *options = nullptr;
1637 EXPECT_EQ(printCupsClient.FillLandscapeOptions(jobParams, numOptions, &options), 2);
1638 delete jobParams;
1639 delete options;
1640 }
1641
1642 /**
1643 * @tc.name: PrintCupsClientTest_0087
1644 * @tc.desc: DeviceCb_ShouldAddPrinterInfo_WhenDeviceUriStartsWithUSBAndPrinterMakeIsNotUnknown
1645 * @tc.type: FUNC
1646 * @tc.require:
1647 */
1648 HWTEST_F(PrintCupsClientTest, DeviceCb_WhenUsbDevice_ShouldAdd, TestSize.Level0)
1649 {
1650 // Arrange
1651 std::string deviceUri = "usb://printer";
1652 std::string deviceClass = "printer";
1653 std::string deviceId = "model123";
1654 std::string deviceInfo = "model123";
1655 std::string deviceMakeAndModel = "model123";
1656 std::string deviceLocation = "location123";
1657 void *userData = nullptr;
1658 // Act
1659 ClearUsbPrinters();
1660 ClearBackendPrinters();
1661 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1662 deviceUri.c_str(), deviceLocation.c_str(), userData);
1663 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1664 deviceUri.c_str(), nullptr, userData);
1665 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1666 "usb://printer_serial=123&111", deviceLocation.c_str(), userData);
1667 // Assert
1668 auto usbPrinters = GetUsbPrinters();
1669 EXPECT_EQ(usbPrinters.size(), 3);
1670 EXPECT_STREQ(usbPrinters[0].GetUri().c_str(), deviceUri.c_str());
1671 EXPECT_STREQ(usbPrinters[0].GetPrinterMake().c_str(), deviceMakeAndModel.c_str());
1672 auto backendPrinters = GetBackendPrinters();
1673 EXPECT_EQ(backendPrinters.size(), 0);
1674 }
1675
1676 /**
1677 * @tc.name: PrintCupsClientTest_0088
1678 * @tc.desc: DeviceCb_ShouldNotAddPrinterInfo_WhenDeviceUriDoesNotStartWithUSB
1679 * @tc.type: FUNC
1680 * @tc.require:
1681 */
1682 HWTEST_F(PrintCupsClientTest, DeviceCb_WhenVendorDevice_ShouldAdd, TestSize.Level0)
1683 {
1684 // Arrange
1685 std::string deviceUri = "vendor://printer";
1686 std::string deviceClass = "printer";
1687 std::string deviceId = "model123";
1688 std::string deviceInfo = "model123";
1689 std::string deviceMakeAndModel = "model123";
1690 std::string deviceLocation = "location123";
1691 void *userData = nullptr;
1692 // Act
1693 ClearUsbPrinters();
1694 ClearBackendPrinters();
1695 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1696 deviceUri.c_str(), deviceLocation.c_str(), userData);
1697 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1698 deviceUri.c_str(), nullptr, userData);
1699 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1700 "vendor://printer_serial=123&111", deviceLocation.c_str(), userData);
1701 // Assert
1702 auto usbPrinters = GetUsbPrinters();
1703 EXPECT_EQ(usbPrinters.size(), 0);
1704 auto backendPrinters = GetBackendPrinters();
1705 EXPECT_EQ(backendPrinters.size(), 3);
1706 }
1707
1708 /**
1709 * @tc.name: PrintCupsClientTest_0089
1710 * @tc.desc: DeviceCb_ShouldNotAddPrinterInfo_WhenPrinterMakeIsUnknown
1711 * @tc.type: FUNC
1712 * @tc.require:
1713 */
1714 HWTEST_F(PrintCupsClientTest, DeviceCb_WhenUnknownMake_ShouldIgnore, TestSize.Level1)
1715 {
1716 // Arrange
1717 std::string deviceUri = "usb://printer";
1718 std::string deviceClass = "printer";
1719 std::string deviceId = "model123";
1720 std::string deviceInfo = "model123";
1721 std::string deviceMakeAndModel = "Unknown";
1722 std::string deviceLocation = "location123";
1723 void *userData = nullptr;
1724 // Act
1725 ClearUsbPrinters();
1726 ClearBackendPrinters();
1727 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1728 deviceUri.c_str(), deviceLocation.c_str(), userData);
1729 deviceUri = "vendor://printer";
1730 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1731 deviceUri.c_str(), deviceLocation.c_str(), userData);
1732 // Assert
1733 auto usbPrinters = GetUsbPrinters();
1734 EXPECT_EQ(usbPrinters.size(), 0);
1735 auto backendPrinters = GetBackendPrinters();
1736 EXPECT_EQ(backendPrinters.size(), 0);
1737 }
1738
1739 /**
1740 * @tc.name: PrintCupsClientTest_0090
1741 * @tc.desc: DeviceCb_ShouldNotAddPrinterInfo_WhenParamNull
1742 * @tc.type: FUNC
1743 * @tc.require:
1744 */
1745 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0090_NeedRename, TestSize.Level1)
1746 {
1747 // Arrange
1748 std::string deviceUri = "usb://printer";
1749 std::string deviceClass = "printer";
1750 std::string deviceId = "model123";
1751 std::string deviceInfo = "model123";
1752 std::string deviceMakeAndModel = "Unknown";
1753 std::string deviceLocation = "location123";
1754 void *userData = nullptr;
1755 // Act
1756 DeviceCb(nullptr, deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1757 deviceUri.c_str(), deviceLocation.c_str(), userData);
1758 DeviceCb(deviceClass.c_str(), nullptr, deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1759 deviceUri.c_str(), deviceLocation.c_str(), userData);
1760 DeviceCb(deviceClass.c_str(), deviceId.c_str(), nullptr, deviceMakeAndModel.c_str(),
1761 deviceUri.c_str(), deviceLocation.c_str(), userData);
1762 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), nullptr,
1763 deviceUri.c_str(), deviceLocation.c_str(), userData);
1764 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1765 nullptr, deviceLocation.c_str(), userData);
1766 // Assert
1767 auto usbPrinters = GetUsbPrinters();
1768 EXPECT_EQ(usbPrinters.size(), 0);
1769 }
1770
1771 /**
1772 * @tc.name: PrintCupsClientTest_0091
1773 * @tc.desc: DeviceCb_Serial
1774 * @tc.type: FUNC
1775 * @tc.require:
1776 */
1777 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0091_NeedRename, TestSize.Level1)
1778 {
1779 // Arrange
1780 std::string deviceUri = "usb://printer_serial=123&111";
1781 std::string deviceClass = "printer";
1782 std::string deviceId = "model123";
1783 std::string deviceInfo = "model123";
1784 std::string deviceMakeAndModel = "model123";
1785 std::string deviceLocation = "1234-";
1786 void *userData = nullptr;
1787 // Act
1788 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1789 deviceUri.c_str(), deviceLocation.c_str(), userData);
1790 deviceLocation = "1234-5678";
1791 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1792 deviceUri.c_str(), deviceLocation.c_str(), userData);
1793 DeviceCb(deviceClass.c_str(), deviceId.c_str(), deviceInfo.c_str(), deviceMakeAndModel.c_str(),
1794 deviceUri.c_str(), nullptr, userData);
1795 // Assert
1796 auto usbPrinters = GetUsbPrinters();
1797 EXPECT_EQ(usbPrinters.size(), 3);
1798 EXPECT_STREQ(usbPrinters[0].GetUri().c_str(), deviceUri.c_str());
1799 EXPECT_STREQ(usbPrinters[0].GetPrinterMake().c_str(), deviceMakeAndModel.c_str());
1800 EXPECT_STREQ(usbPrinters[0].GetPrinterId().c_str(), "USB-model123-123");
1801 ClearUsbPrinters();
1802 }
1803
1804 /**
1805 * @tc.name: PrintCupsClientTest_0092
1806 * @tc.desc: GetUsbPrinterSerial
1807 * @tc.type: FUNC
1808 * @tc.require:
1809 */
1810 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0092_NeedRename, TestSize.Level1)
1811 {
1812 std::string usb = "usb://";
1813 std::string serial = "serial=";
1814 std::string num = "11";
1815 std::string deviceUri = usb;
1816 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), "");
1817 deviceUri = usb + serial;
1818 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), "");
1819 deviceUri = usb + serial + num;
1820 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), num.c_str());
1821 deviceUri = usb + serial + num + "&postfix";
1822 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), num.c_str());
1823 deviceUri = usb + serial + "1234567890" + "&postfix";
1824 EXPECT_STREQ(GetUsbPrinterSerial(deviceUri).c_str(), "567890");
1825 }
1826
1827 /**
1828 * @tc.name: PrintCupsClientTest_0093
1829 * @tc.desc: StandardizePrinterUri
1830 * @tc.type: FUNC
1831 * @tc.require:
1832 */
1833 HWTEST_F(PrintCupsClientTest, PrintCupsClientTest_0093_NeedRename, TestSize.Level1)
1834 {
1835 std::string printerUri = "test";
1836 EXPECT_STREQ(StandardizePrinterUri(printerUri, "").c_str(), printerUri.c_str());
1837 EXPECT_STREQ(StandardizePrinterUri(printerUri, BSUNI_PPD_NAME).c_str(), printerUri.c_str());
1838 EXPECT_STREQ(StandardizePrinterUri("ipp://test", BSUNI_PPD_NAME).c_str(), "bsUniBackend://test");
1839 }
1840
1841 /**
1842 * @tc.name: PrintCupsClientTest_0094
1843 * @tc.desc: FillAdvancedOptions
1844 * @tc.type: FUNC
1845 * @tc.require:
1846 */
1847 HWTEST_F(PrintCupsClientTest, FillAdvancedOptions_SetAdvancedOpsJson_NumOptionsReturnOne, TestSize.Level1)
1848 {
1849 int num = 0;
1850 cups_option_t *options = nullptr;
1851 OHOS::Print::PrintCupsClient printCupsClient;
1852 PrintJob jobInfo;
1853 jobInfo.SetCopyNumber(2);
1854 jobInfo.SetDuplexMode(1);
1855 jobInfo.SetColorMode(0);
1856 jobInfo.SetOption(JOB_OPTIONS);
1857 JobParameters *jobParams = printCupsClient.BuildJobParameters(jobInfo, JOB_USER_NAME);
1858 Json::Value advancedOpsJson;
1859 advancedOpsJson["key"] = "value";
1860 jobParams->advancedOpsJson = advancedOpsJson;
1861 int ret = printCupsClient.FillAdvancedOptions(jobParams, num, &options);
1862 EXPECT_EQ(ret, 1);
1863 delete jobParams;
1864 delete options;
1865 }
1866
1867 /**
1868 * @tc.name: PrintCupsClientTest_0095
1869 * @tc.desc: FillAdvancedOptions
1870 * @tc.type: FUNC
1871 * @tc.require:
1872 */
1873 HWTEST_F(PrintCupsClientTest, FillAdvancedOptions_SetNullAdvancedOpsJson_ReturnCorrectNumOptions, TestSize.Level1)
1874 {
1875 int num = 0;
1876 cups_option_t *options = nullptr;
1877 OHOS::Print::PrintCupsClient printCupsClient;
1878 PrintJob jobInfo;
1879 jobInfo.SetCopyNumber(2);
1880 jobInfo.SetDuplexMode(1);
1881 jobInfo.SetColorMode(0);
1882 jobInfo.SetOption(JOB_OPTIONS);
1883 JobParameters *jobParams = printCupsClient.BuildJobParameters(jobInfo, JOB_USER_NAME);
1884 Json::Value advancedOpsJson;
1885 jobParams->advancedOpsJson = advancedOpsJson;
1886 int ret = printCupsClient.FillAdvancedOptions(jobParams, num, &options);
1887 EXPECT_EQ(ret, 0);
1888 delete jobParams;
1889 delete options;
1890 }
1891
1892 /**
1893 * @tc.name: PrintCupsClientTest_0096
1894 * @tc.desc: UpdateJobParameterByBoolOption
1895 * @tc.type: FUNC
1896 * @tc.require:
1897 */
1898 HWTEST_F(PrintCupsClientTest,
1899 UpdateJobParameterByBoolOption_SetCorrectValue_ReturnSameParamValue, TestSize.Level1)
1900 {
1901 OHOS::Print::PrintCupsClient printCupsClient;
1902 Json::Value optionJson;
1903 JobParameters *jobParams = new JobParameters();
1904 optionJson["isBorderless"] = false;
1905 optionJson["isAutoRotate"] = false;
1906 optionJson["isReverse"] = false;
1907 optionJson["isCollate"] = false;
1908 printCupsClient.UpdateJobParameterByBoolOption(optionJson, jobParams);
1909 EXPECT_EQ(jobParams->borderless, optionJson["isBorderless"].asBool());
1910 delete jobParams;
1911 }
1912
1913 /**
1914 * @tc.name: PrintCupsClientTest_0097
1915 * @tc.desc: UpdateJobParameterByBoolOption
1916 * @tc.type: FUNC
1917 * @tc.require:
1918 */
1919 HWTEST_F(PrintCupsClientTest,
1920 UpdateJobParameterByBoolOption_SetWrongTypeValue_ReturndefaultValue, TestSize.Level1)
1921 {
1922 OHOS::Print::PrintCupsClient printCupsClient;
1923 Json::Value optionJson;
1924 JobParameters *jobParams = new JobParameters();
1925 optionJson["isBorderless"] = 1;
1926 optionJson["isAutoRotate"] = 1;
1927 optionJson["isReverse"] = 1;
1928 optionJson["isCollate"] = 1;
1929 printCupsClient.UpdateJobParameterByBoolOption(optionJson, jobParams);
1930 EXPECT_EQ(jobParams->borderless, 1);
1931 delete jobParams;
1932 }
1933
1934 /**
1935 * @tc.name: PrintCupsClientTest_0098
1936 * @tc.desc: UpdateJobParameterByBoolOption
1937 * @tc.type: FUNC
1938 * @tc.require:
1939 */
1940 HWTEST_F(PrintCupsClientTest,
1941 UpdateJobParameterByBoolOption_NoValueSet_ReturndefaultValue, TestSize.Level1)
1942 {
1943 OHOS::Print::PrintCupsClient printCupsClient;
1944 Json::Value optionJson;
1945 JobParameters *jobParams = new JobParameters();
1946 printCupsClient.UpdateJobParameterByBoolOption(optionJson, jobParams);
1947 EXPECT_EQ(jobParams->borderless, 1);
1948 delete jobParams;
1949 }
1950
1951 /**
1952 * @tc.name: PrintCupsClientTest_0099
1953 * @tc.desc: UpdateJobParameterByOption
1954 * @tc.type: FUNC
1955 * @tc.require:
1956 */
1957 HWTEST_F(PrintCupsClientTest,
1958 UpdateJobParameterByOption_SetCorrectValue_ReturnSameParamValue, TestSize.Level1)
1959 {
1960 OHOS::Print::PrintCupsClient printCupsClient;
1961 Json::Value optionJson;
1962 JobParameters *jobParams = new JobParameters();
1963 optionJson["cupsOptions"] = "1";
1964 optionJson["printQuality"] = "4";
1965 optionJson["jobName"] = "1";
1966 optionJson["mediaType"] = "1";
1967 Json::Value advancedOptions;
1968 advancedOptions["key"] = "value";
1969 optionJson["advancedOptions"] = advancedOptions;
1970 printCupsClient.UpdateJobParameterByOption(optionJson, jobParams);
1971 EXPECT_EQ(jobParams->printQuality, optionJson["printQuality"].asString());
1972 delete jobParams;
1973 }
1974
1975 /**
1976 * @tc.name: PrintCupsClientTest_0100
1977 * @tc.desc: UpdateJobParameterByOption
1978 * @tc.type: FUNC
1979 * @tc.require:
1980 */
1981 HWTEST_F(PrintCupsClientTest,
1982 UpdateJobParameterByOption_SetWrongTypeValue_ReturndefaultValue, TestSize.Level1)
1983 {
1984 OHOS::Print::PrintCupsClient printCupsClient;
1985 Json::Value optionJson;
1986 JobParameters *jobParams = new JobParameters();
1987 optionJson["cupsOptions"] = 1;
1988 optionJson["printQuality"] = 4;
1989 optionJson["jobName"] = 1;
1990 optionJson["mediaType"] = 1;
1991 optionJson["advancedOptions"] = 1;
1992 printCupsClient.UpdateJobParameterByOption(optionJson, jobParams);
1993 EXPECT_EQ(jobParams->printQuality, CUPS_PRINT_QUALITY_NORMAL);
1994 delete jobParams;
1995 }
1996
1997 /**
1998 * @tc.name: PrintCupsClientTest_0101
1999 * @tc.desc: UpdateJobParameterByOption
2000 * @tc.type: FUNC
2001 * @tc.require:
2002 */
2003 HWTEST_F(PrintCupsClientTest,
2004 UpdateJobParameterByOption_NoValueSet_ReturndefaultValue, TestSize.Level1)
2005 {
2006 OHOS::Print::PrintCupsClient printCupsClient;
2007 Json::Value optionJson;
2008 JobParameters *jobParams = new JobParameters();
2009 printCupsClient.UpdateJobParameterByOption(optionJson, jobParams);
2010 EXPECT_EQ(jobParams->printQuality, CUPS_PRINT_QUALITY_NORMAL);
2011 delete jobParams;
2012 }
2013 } // namespace Print
2014 } // namespace OHOS