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 <gtest/gtest.h>
17 #include "mock_print_service.h"
18 #include "print_manager_client.h"
19 #include "iremote_broker.h"
20 #include "print_constant.h"
21 #include "print_log.h"
22 #include "print_resolution.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Print {
29 class PrintServiceStubTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 };
36
SetUpTestCase(void)37 void PrintServiceStubTest::SetUpTestCase(void) {}
38
TearDownTestCase(void)39 void PrintServiceStubTest::TearDownTestCase(void) {}
40
SetUp(void)41 void PrintServiceStubTest::SetUp(void) {}
42
TearDown(void)43 void PrintServiceStubTest::TearDown(void) {}
44
45 /**
46 * @tc.name: PrintServiceStubTest_0001
47 * @tc.desc: Verify the capability function.
48 * @tc.type: FUNC
49 * @tc.require:
50 */
51 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0001, TestSize.Level1)
52 {
53 MessageParcel data;
54 MessageParcel reply;
55 MessageOption option(MessageOption::TF_SYNC);
56 uint32_t code = static_cast<uint32_t>(CMD_START_PRINT);
57
58 auto stub = std::make_shared<MockPrintService>();
59 EXPECT_NE(stub, nullptr);
60 EXPECT_EQ(stub->OnRemoteRequest(code, data, reply, option), E_PRINT_RPC_FAILURE);
61 }
62
63 /**
64 * @tc.name: PrintServiceStubTest_0002
65 * @tc.desc: Verify the capability function.
66 * @tc.type: FUNC
67 * @tc.require:
68 */
69 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0002, TestSize.Level1)
70 {
71 MessageParcel data;
72 MessageParcel reply;
73 MessageOption option(MessageOption::TF_SYNC);
74 uint32_t code = static_cast<uint32_t>(CMD_START_PRINT + 100);
75
76 EXPECT_TRUE(data.WriteInterfaceToken(IPrintService::GetDescriptor()));
77 auto stub = std::make_shared<MockPrintService>();
78 EXPECT_NE(stub, nullptr);
79 EXPECT_EQ(stub->OnRemoteRequest(code, data, reply, option), OHOS::IPC_STUB_UNKNOW_TRANS_ERR);
80 }
81
82 /**
83 * @tc.name: PrintServiceStubTest_0003
84 * @tc.desc: Verify the capability function.
85 * @tc.type: FUNC
86 * @tc.require:
87 */
88 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0003, TestSize.Level1)
89 {
90 MessageParcel data;
91 MessageParcel reply;
92 MessageOption option(MessageOption::TF_SYNC);
93 uint32_t code = static_cast<uint32_t>(CMD_START_PRINT);
94 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
95 EXPECT_TRUE(data.WriteBool(false));
96 EXPECT_TRUE(data.WriteBool(false));
97 EXPECT_TRUE(data.WriteString("jobId"));
98
99 auto stub = std::make_shared<MockPrintService>();
100 EXPECT_NE(stub, nullptr);
101 ON_CALL(*stub, StartPrint(_, _, _)).WillByDefault(Return(E_PRINT_NONE));
102 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
103 }
104
105 /**
106 * @tc.name: PrintServiceStubTest_0004
107 * @tc.desc: Verify the capability function.
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0004, TestSize.Level1)
112 {
113 MessageParcel data;
114 MessageParcel reply;
115 MessageOption option(MessageOption::TF_SYNC);
116 uint32_t code = static_cast<uint32_t>(CMD_START_PRINT);
117
118 std::vector<std::string> testFileList;
119 testFileList.resize(1001);
120 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
121 EXPECT_TRUE(data.WriteBool(testFileList.size() > 0));
122 EXPECT_TRUE(data.WriteStringVector(testFileList));
123 EXPECT_TRUE(data.WriteBool(false));
124 EXPECT_TRUE(data.WriteString("jobId"));
125
126 auto stub = std::make_shared<MockPrintService>();
127 EXPECT_NE(stub, nullptr);
128 ON_CALL(*stub, StartPrint(_, _, _)).WillByDefault(Return(E_PRINT_NONE));
129 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
130 }
131
132 /**
133 * @tc.name: PrintServiceStubTest_0005
134 * @tc.desc: Verify the capability function.
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0005, TestSize.Level1)
139 {
140 MessageParcel data;
141 MessageParcel reply;
142 MessageOption option(MessageOption::TF_SYNC);
143 uint32_t code = static_cast<uint32_t>(CMD_START_PRINT);
144
145 std::vector<std::string> testFileList = {"file://data/print/a.png",
146 "file://data/print/b.png", "file://data/print/c.png"};
147 std::vector<uint32_t> testFdList;
148 testFdList.resize(1001);
149
150 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
151 EXPECT_TRUE(data.WriteBool(testFileList.size() > 0));
152 EXPECT_TRUE(data.WriteStringVector(testFileList));
153 EXPECT_TRUE(data.WriteBool(testFdList.size() > 0));
154 EXPECT_TRUE(data.WriteInt32(testFdList.size()));
155 EXPECT_TRUE(data.WriteString("jobId"));
156
157 auto stub = std::make_shared<MockPrintService>();
158 EXPECT_NE(stub, nullptr);
159 ON_CALL(*stub, StartPrint(_, _, _)).WillByDefault(Return(E_PRINT_NONE));
160 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
161 }
162
163 /**
164 * @tc.name: PrintServiceStubTest_0006
165 * @tc.desc: Verify the capability function.
166 * @tc.type: FUNC
167 * @tc.require:
168 */
169 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0006, TestSize.Level1)
170 {
171 MessageParcel data;
172 MessageParcel reply;
173 MessageOption option(MessageOption::TF_SYNC);
174 uint32_t code = static_cast<uint32_t>(CMD_START_PRINT);
175
176 std::vector<std::string> testFileList = {"file://data/print/a.png",
177 "file://data/print/b.png", "file://data/print/c.png"};
178 std::vector<uint32_t> testFdList = {1, 2};
179 std::string testTaskId = "2";
180
181 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
182 EXPECT_TRUE(data.WriteBool(testFileList.size() > 0));
183 EXPECT_TRUE(data.WriteStringVector(testFileList));
184 EXPECT_TRUE(data.WriteBool(testFdList.size() > 0));
185 EXPECT_TRUE(data.WriteInt32(testFdList.size()));
186 for (auto fd : testFdList) {
187 data.WriteFileDescriptor(fd);
188 }
189 EXPECT_TRUE(data.WriteString("jobId"));
190
191 auto stub = std::make_shared<MockPrintService>();
192 EXPECT_NE(stub, nullptr);
193 ON_CALL(*stub, StartPrint(_, _, _)).WillByDefault(Return(E_PRINT_NONE));
194 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
195 }
196
197 /**
198 * @tc.name: PrintServiceStubTest_0007
199 * @tc.desc: Verify the capability function.
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0007, TestSize.Level1)
204 {
205 MessageParcel data;
206 MessageParcel reply;
207 MessageOption option(MessageOption::TF_SYNC);
208 uint32_t code = static_cast<uint32_t>(CMD_STOP_PRINT);
209
210 std::string testTaskId = "2";
211
212 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
213 EXPECT_TRUE(data.WriteString(testTaskId));
214
215 auto stub = std::make_shared<MockPrintService>();
216 EXPECT_NE(stub, nullptr);
217 ON_CALL(*stub, StopPrint).WillByDefault(Return(E_PRINT_NONE));
218 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
219 }
220
221 /**
222 * @tc.name: PrintServiceStubTest_0008
223 * @tc.desc: Verify the capability function.
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0008, TestSize.Level1)
228 {
229 MessageParcel data;
230 MessageParcel reply;
231 MessageOption option(MessageOption::TF_SYNC);
232 uint32_t code = static_cast<uint32_t>(CMD_CONNECTPRINTER);
233
234 std::string testPrinterId = "com.sample.ext:1";
235
236 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
237 EXPECT_TRUE(data.WriteString(testPrinterId));
238
239 auto stub = std::make_shared<MockPrintService>();
240 EXPECT_NE(stub, nullptr);
241 ON_CALL(*stub, ConnectPrinter).WillByDefault(Return(E_PRINT_NONE));
242 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
243 }
244
245 /**
246 * @tc.name: PrintServiceStubTest_0009
247 * @tc.desc: Verify the capability function.
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0009, TestSize.Level1)
252 {
253 MessageParcel data;
254 MessageParcel reply;
255 MessageOption option(MessageOption::TF_SYNC);
256 uint32_t code = static_cast<uint32_t>(CMD_DISCONNECTPRINTER);
257
258 std::string testPrinterId = "com.sample.ext:1";
259
260 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
261 EXPECT_TRUE(data.WriteString(testPrinterId));
262
263 auto stub = std::make_shared<MockPrintService>();
264 EXPECT_NE(stub, nullptr);
265 ON_CALL(*stub, DisconnectPrinter).WillByDefault(Return(E_PRINT_NONE));
266 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
267 }
268
269 /**
270 * @tc.name: PrintServiceStubTest_0010
271 * @tc.desc: Verify the capability function.
272 * @tc.type: FUNC
273 * @tc.require:
274 */
275 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0010, TestSize.Level1)
276 {
277 MessageParcel data;
278 MessageParcel reply;
279 MessageOption option(MessageOption::TF_SYNC);
280 uint32_t code = static_cast<uint32_t>(CMD_STARTDISCOVERPRINTER);
281
282 std::vector<std::string> testExtensionList;
283 std::string extensionId = "com.sample.ext";
284 testExtensionList.emplace_back(extensionId);
285
286 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
287 EXPECT_TRUE(data.WriteStringVector(testExtensionList));
288
289 auto stub = std::make_shared<MockPrintService>();
290 EXPECT_NE(stub, nullptr);
291 ON_CALL(*stub, StartDiscoverPrinter).WillByDefault(Return(E_PRINT_NONE));
292 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
293 }
294
295 /**
296 * @tc.name: PrintServiceStubTest_0011
297 * @tc.desc: Verify the capability function.
298 * @tc.type: FUNC
299 * @tc.require:
300 */
301 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0011, TestSize.Level1)
302 {
303 MessageParcel data;
304 MessageParcel reply;
305 MessageOption option(MessageOption::TF_SYNC);
306 uint32_t code = static_cast<uint32_t>(CMD_STOPDISCOVERPRINTER);
307
308 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
309
310 auto stub = std::make_shared<MockPrintService>();
311 EXPECT_NE(stub, nullptr);
312 ON_CALL(*stub, StopDiscoverPrinter).WillByDefault(Return(E_PRINT_NONE));
313 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
314 }
315
316 /**
317 * @tc.name: PrintServiceStubTest_0012
318 * @tc.desc: Verify the capability function.
319 * @tc.type: FUNC
320 * @tc.require:
321 */
322 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0012, TestSize.Level1)
323 {
324 MessageParcel data;
325 MessageParcel reply;
326 MessageOption option(MessageOption::TF_SYNC);
327 uint32_t code = static_cast<uint32_t>(CMD_QUERYALLEXTENSION);
328
329 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
330
331 auto stub = std::make_shared<MockPrintService>();
332 EXPECT_NE(stub, nullptr);
333 ON_CALL(*stub, QueryAllExtension).WillByDefault(Return(E_PRINT_NONE));
334 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
335 }
336
337 /**
338 * @tc.name: PrintServiceStubTest_0013
339 * @tc.desc: Verify the capability function.
340 * @tc.type: FUNC
341 * @tc.require:
342 */
343 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0013, TestSize.Level1)
344 {
345 MessageParcel data;
346 MessageParcel reply;
347 MessageOption option(MessageOption::TF_SYNC);
348 uint32_t code = static_cast<uint32_t>(CMD_QUERYALLEXTENSION);
349
350 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
351
352 auto stub = std::make_shared<MockPrintService>();
353 EXPECT_NE(stub, nullptr);
354 ON_CALL(*stub, QueryAllExtension).WillByDefault(Return(E_PRINT_GENERIC_FAILURE));
355 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
356 }
357
358 /**
359 * @tc.name: PrintServiceStubTest_0014
360 * @tc.desc: Verify the capability function.
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0014, TestSize.Level1)
365 {
366 MessageParcel data;
367 MessageParcel reply;
368 MessageOption option(MessageOption::TF_SYNC);
369 uint32_t code = static_cast<uint32_t>(CMD_STARTPRINTJOB);
370
371 PrintJob testJob;
372 std::string jobId = "job:1234";
373 testJob.SetJobId(jobId);
374
375 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
376 EXPECT_TRUE(testJob.Marshalling(data));
377
378 auto stub = std::make_shared<MockPrintService>();
379 EXPECT_NE(stub, nullptr);
380 ON_CALL(*stub, StartPrintJob).WillByDefault(Return(E_PRINT_NONE));
381 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
382 }
383
384 /**
385 * @tc.name: PrintServiceStubTest_0015
386 * @tc.desc: Verify the capability function.
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0015, TestSize.Level1)
391 {
392 MessageParcel data;
393 MessageParcel reply;
394 MessageOption option(MessageOption::TF_SYNC);
395 uint32_t code = static_cast<uint32_t>(CMD_CANCELPRINTJOB);
396
397 std::string jobId = "job:1234";
398
399 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
400 EXPECT_TRUE(data.WriteString(jobId));
401
402 auto stub = std::make_shared<MockPrintService>();
403 EXPECT_NE(stub, nullptr);
404 ON_CALL(*stub, CancelPrintJob).WillByDefault(Return(E_PRINT_NONE));
405 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
406 }
407
408 /**
409 * @tc.name: PrintServiceStubTest_0016
410 * @tc.desc: Verify the capability function.
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0016, TestSize.Level1)
415 {
416 MessageParcel data;
417 MessageParcel reply;
418 MessageOption option(MessageOption::TF_SYNC);
419 uint32_t code = static_cast<uint32_t>(CMD_ADDPRINTERS);
420
421 uint32_t testSize = 1001;
422
423 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
424 EXPECT_TRUE(data.WriteUint32(testSize));
425
426 auto stub = std::make_shared<MockPrintService>();
427 EXPECT_NE(stub, nullptr);
428 ON_CALL(*stub, AddPrinters).WillByDefault(Return(E_PRINT_NONE));
429 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
430 }
431
432 /**
433 * @tc.name: PrintServiceStubTest_0017
434 * @tc.desc: Verify the capability function.
435 * @tc.type: FUNC
436 * @tc.require:
437 */
438 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0017, TestSize.Level1)
439 {
440 MessageParcel data;
441 MessageParcel reply;
442 MessageOption option(MessageOption::TF_SYNC);
443 uint32_t code = static_cast<uint32_t>(CMD_ADDPRINTERS);
444
445
446 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
447 EXPECT_TRUE(data.WriteUint32(0));
448
449 auto stub = std::make_shared<MockPrintService>();
450 EXPECT_NE(stub, nullptr);
451 ON_CALL(*stub, AddPrinters).WillByDefault(Return(E_PRINT_NONE));
452 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
453 }
454
455 /**
456 * @tc.name: PrintServiceStubTest_0018
457 * @tc.desc: Verify the capability function.
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0018, TestSize.Level1)
462 {
463 MessageParcel data;
464 MessageParcel reply;
465 MessageOption option(MessageOption::TF_SYNC);
466 uint32_t code = static_cast<uint32_t>(CMD_ADDPRINTERS);
467
468 PrinterInfo testInfo;
469 std::string testPrinterId = "com.sample.ext:1";
470 testInfo.SetPrinterId(testPrinterId);
471 std::vector<PrinterInfo> printerInfos;
472 printerInfos.emplace_back(testInfo);
473
474 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
475 EXPECT_TRUE(data.WriteUint32(static_cast<uint32_t>(printerInfos.size())));
476 for (size_t index = 0; index < printerInfos.size(); index++) {
477 printerInfos[index].Marshalling(data);
478 }
479
480 auto stub = std::make_shared<MockPrintService>();
481 EXPECT_NE(stub, nullptr);
482 ON_CALL(*stub, AddPrinters).WillByDefault(Return(E_PRINT_NONE));
483 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
484 }
485
486 /**
487 * @tc.name: PrintServiceStubTest_0019
488 * @tc.desc: Verify the capability function.
489 * @tc.type: FUNC
490 * @tc.require:
491 */
492 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0019, TestSize.Level1)
493 {
494 MessageParcel data;
495 MessageParcel reply;
496 MessageOption option(MessageOption::TF_SYNC);
497 uint32_t code = static_cast<uint32_t>(CMD_REMOVEPRINTERS);
498
499 std::vector<std::string> printerIds;
500 printerIds.resize(1001);
501
502 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
503 EXPECT_TRUE(data.WriteStringVector(printerIds));
504
505 auto stub = std::make_shared<MockPrintService>();
506 EXPECT_NE(stub, nullptr);
507 ON_CALL(*stub, RemovePrinters).WillByDefault(Return(E_PRINT_NONE));
508 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
509 }
510
511 /**
512 * @tc.name: PrintServiceStubTest_0020
513 * @tc.desc: Verify the capability function.
514 * @tc.type: FUNC
515 * @tc.require:
516 */
517 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0020, TestSize.Level1)
518 {
519 MessageParcel data;
520 MessageParcel reply;
521 MessageOption option(MessageOption::TF_SYNC);
522 uint32_t code = static_cast<uint32_t>(CMD_REMOVEPRINTERS);
523
524 std::string testPrinterId = "com.sample.ext:1";
525 std::vector<std::string> printerIds;
526 printerIds.emplace_back(testPrinterId);
527
528 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
529 EXPECT_TRUE(data.WriteStringVector(printerIds));
530
531 auto stub = std::make_shared<MockPrintService>();
532 EXPECT_NE(stub, nullptr);
533 ON_CALL(*stub, RemovePrinters).WillByDefault(Return(E_PRINT_NONE));
534 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
535 }
536
537 /**
538 * @tc.name: PrintServiceStubTest_0021
539 * @tc.desc: Verify the capability function.
540 * @tc.type: FUNC
541 * @tc.require:
542 */
543 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0021, TestSize.Level1)
544 {
545 MessageParcel data;
546 MessageParcel reply;
547 MessageOption option(MessageOption::TF_SYNC);
548 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERS);
549
550 uint32_t testSize = 1001;
551
552 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
553 EXPECT_TRUE(data.WriteUint32(testSize));
554
555 auto stub = std::make_shared<MockPrintService>();
556 EXPECT_NE(stub, nullptr);
557 ON_CALL(*stub, UpdatePrinters).WillByDefault(Return(E_PRINT_NONE));
558 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
559 }
560
561 /**
562 * @tc.name: PrintServiceStubTest_0022
563 * @tc.desc: Verify the capability function.
564 * @tc.type: FUNC
565 * @tc.require:
566 */
567 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0022, TestSize.Level1)
568 {
569 MessageParcel data;
570 MessageParcel reply;
571 MessageOption option(MessageOption::TF_SYNC);
572 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERS);
573
574
575 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
576 EXPECT_TRUE(data.WriteUint32(0));
577
578 auto stub = std::make_shared<MockPrintService>();
579 EXPECT_NE(stub, nullptr);
580 ON_CALL(*stub, UpdatePrinters).WillByDefault(Return(E_PRINT_NONE));
581 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
582 }
583
584 /**
585 * @tc.name: PrintServiceStubTest_0023
586 * @tc.desc: Verify the capability function.
587 * @tc.type: FUNC
588 * @tc.require:
589 */
590 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0023, TestSize.Level1)
591 {
592 MessageParcel data;
593 MessageParcel reply;
594 MessageOption option(MessageOption::TF_SYNC);
595 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERS);
596
597 PrinterInfo testInfo;
598 std::string testPrinterId = "com.sample.ext:1";
599 testInfo.SetPrinterId(testPrinterId);
600 std::vector<PrinterInfo> printerInfos;
601 printerInfos.emplace_back(testInfo);
602
603 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
604 EXPECT_TRUE(data.WriteUint32(static_cast<uint32_t>(printerInfos.size())));
605 for (size_t index = 0; index < printerInfos.size(); index++) {
606 printerInfos[index].Marshalling(data);
607 }
608
609 auto stub = std::make_shared<MockPrintService>();
610 EXPECT_NE(stub, nullptr);
611 ON_CALL(*stub, UpdatePrinters).WillByDefault(Return(E_PRINT_NONE));
612 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
613 }
614
615 /**
616 * @tc.name: PrintServiceStubTest_0025
617 * @tc.desc: Verify the capability function.
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0025, TestSize.Level1)
622 {
623 MessageParcel data;
624 MessageParcel reply;
625 MessageOption option(MessageOption::TF_SYNC);
626 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERSTATE);
627
628 std::string testPrinterId = "com.sample.ext:1";
629 uint32_t testState = static_cast<uint32_t>(PRINTER_ADDED);
630
631 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
632 EXPECT_TRUE(data.WriteString(testPrinterId));
633 EXPECT_TRUE(data.WriteUint32(testState));
634
635 auto stub = std::make_shared<MockPrintService>();
636 EXPECT_NE(stub, nullptr);
637 ON_CALL(*stub, UpdatePrinterState).WillByDefault(Return(E_PRINT_NONE));
638 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
639 }
640
641 /**
642 * @tc.name: PrintServiceStubTest_0026
643 * @tc.desc: Verify the capability function.
644 * @tc.type: FUNC
645 * @tc.require:
646 */
647 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0026, TestSize.Level1)
648 {
649 MessageParcel data;
650 MessageParcel reply;
651 MessageOption option(MessageOption::TF_SYNC);
652 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTJOBSTATE_FORNORMALAPP);
653
654 std::string testJobId = "jodId:1234";
655 uint32_t testState = static_cast<uint32_t>(PRINT_JOB_COMPLETED);
656 uint32_t testSubState = static_cast<uint32_t>(PRINT_JOB_COMPLETED_SUCCESS);
657
658 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
659 EXPECT_TRUE(data.WriteString(testJobId));
660 EXPECT_TRUE(data.WriteUint32(testState));
661 EXPECT_TRUE(data.WriteUint32(testSubState));
662
663 auto stub = std::make_shared<MockPrintService>();
664 EXPECT_NE(stub, nullptr);
665 ON_CALL(*stub, UpdatePrintJobStateOnlyForSystemApp).WillByDefault(Return(E_PRINT_NONE));
666 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
667 }
668
669 /**
670 * @tc.name: PrintServiceStubTest_0027
671 * @tc.desc: Verify the capability function.
672 * @tc.type: FUNC
673 * @tc.require:
674 */
675 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0027, TestSize.Level1)
676 {
677 MessageParcel data;
678 MessageParcel reply;
679 MessageOption option(MessageOption::TF_SYNC);
680 uint32_t code = static_cast<uint32_t>(CMD_UPDATEEXTENSIONINFO);
681
682 std::string testExtInfo = "extinformation";
683
684 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
685 EXPECT_TRUE(data.WriteString(testExtInfo));
686
687 auto stub = std::make_shared<MockPrintService>();
688 EXPECT_NE(stub, nullptr);
689 ON_CALL(*stub, UpdateExtensionInfo).WillByDefault(Return(E_PRINT_NONE));
690 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
691 }
692
693 /**
694 * @tc.name: PrintServiceStubTest_0028
695 * @tc.desc: Verify the capability function.
696 * @tc.type: FUNC
697 * @tc.require:
698 */
699 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0028, TestSize.Level1)
700 {
701 MessageParcel data;
702 MessageParcel reply;
703 MessageOption option(MessageOption::TF_SYNC);
704 uint32_t code = static_cast<uint32_t>(CMD_REQUESTPREVIEW);
705
706 PrintJob testJob;
707 std::string jobId = "job:1234";
708 testJob.SetJobId(jobId);
709
710 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
711 EXPECT_TRUE(testJob.Marshalling(data));
712
713 auto stub = std::make_shared<MockPrintService>();
714 EXPECT_NE(stub, nullptr);
715 ON_CALL(*stub, RequestPreview).WillByDefault(Return(E_PRINT_NONE));
716 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
717 }
718
719 /**
720 * @tc.name: PrintServiceStubTest_0029
721 * @tc.desc: Verify the capability function.
722 * @tc.type: FUNC
723 * @tc.require:
724 */
725 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0029, TestSize.Level1)
726 {
727 MessageParcel data;
728 MessageParcel reply;
729 MessageOption option(MessageOption::TF_SYNC);
730 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERCAPABILITY);
731
732 std::string testPrinterId = "com.sample.ext:1";
733
734 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
735 EXPECT_TRUE(data.WriteString(testPrinterId));
736
737 auto stub = std::make_shared<MockPrintService>();
738 EXPECT_NE(stub, nullptr);
739 ON_CALL(*stub, QueryPrinterCapability).WillByDefault(Return(E_PRINT_NONE));
740 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
741 }
742
743 /**
744 * @tc.name: PrintServiceStubTest_0030
745 * @tc.desc: Verify the capability function.
746 * @tc.type: FUNC
747 * @tc.require:
748 */
749 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0030, TestSize.Level1)
750 {
751 MessageParcel data;
752 MessageParcel reply;
753 MessageOption option(MessageOption::TF_SYNC);
754 uint32_t code = static_cast<uint32_t>(CMD_QUERYALLPRINTJOB);
755
756 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
757
758 auto stub = std::make_shared<MockPrintService>();
759 EXPECT_NE(stub, nullptr);
760 ON_CALL(*stub, QueryAllPrintJob).WillByDefault(Return(E_PRINT_NONE));
761 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
762 }
763
764 /**
765 * @tc.name: PrintServiceStubTest_0031
766 * @tc.desc: Verify the capability function.
767 * @tc.type: FUNC
768 * @tc.require:
769 */
770 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0031, TestSize.Level1)
771 {
772 MessageParcel data;
773 MessageParcel reply;
774 MessageOption option(MessageOption::TF_SYNC);
775 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTJOBBYID);
776
777 std::string jobId = "job:1234";
778 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
779 EXPECT_TRUE(data.WriteString(jobId));
780
781 auto stub = std::make_shared<MockPrintService>();
782 EXPECT_NE(stub, nullptr);
783 ON_CALL(*stub, QueryPrintJobById).WillByDefault(Return(E_PRINT_NONE));
784 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
785 }
786
787 /**
788 * @tc.name: PrintServiceStubTest_0032
789 * @tc.desc: Verify the capability function.
790 * @tc.type: FUNC
791 * @tc.require:
792 */
793 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0032, TestSize.Level1)
794 {
795 MessageParcel data;
796 MessageParcel reply;
797 MessageOption option(MessageOption::TF_SYNC);
798 uint32_t code = static_cast<uint32_t>(CMD_ON);
799
800 std::string taskId = "1234";
801 std::string testType = "";
802 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
803 EXPECT_TRUE(data.WriteString(taskId));
804 EXPECT_TRUE(data.WriteString(testType));
805
806 auto stub = std::make_shared<MockPrintService>();
807 EXPECT_NE(stub, nullptr);
808 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
809 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
810 }
811
812 /**
813 * @tc.name: PrintServiceStubTest_0033
814 * @tc.desc: Verify the capability function.
815 * @tc.type: FUNC
816 * @tc.require:
817 */
818 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0033, TestSize.Level1)
819 {
820 MessageParcel data;
821 MessageParcel reply;
822 MessageOption option(MessageOption::TF_SYNC);
823 uint32_t code = static_cast<uint32_t>(CMD_ON);
824
825 std::string taskId = "1234";
826 std::string testType = "block";
827 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
828 EXPECT_TRUE(data.WriteString(taskId));
829 EXPECT_TRUE(data.WriteString(testType));
830
831 auto stub = std::make_shared<MockPrintService>();
832 EXPECT_NE(stub, nullptr);
833 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
834 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
835 }
836
837 /**
838 * @tc.name: PrintServiceStubTest_0034
839 * @tc.desc: Verify the capability function.
840 * @tc.type: FUNC
841 * @tc.require:
842 */
843 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0034, TestSize.Level1)
844 {
845 MessageParcel data;
846 MessageParcel reply;
847 MessageOption option(MessageOption::TF_SYNC);
848 uint32_t code = static_cast<uint32_t>(CMD_ON);
849
850 std::string taskId = "1234";
851 std::string testType = "block";
852 auto callback = std::make_shared<PrintExtensionCallbackStub>();
853 EXPECT_NE(callback, nullptr);
854 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
855 EXPECT_TRUE(data.WriteString(taskId));
856 EXPECT_TRUE(data.WriteString(testType));
857 EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject().GetRefPtr()));
858
859 auto stub = std::make_shared<MockPrintService>();
860 EXPECT_NE(stub, nullptr);
861 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
862 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
863 }
864
865 /**
866 * @tc.name: PrintServiceStubTest_0035
867 * @tc.desc: Verify the capability function.
868 * @tc.type: FUNC
869 * @tc.require:
870 */
871 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0035, TestSize.Level1)
872 {
873 MessageParcel data;
874 MessageParcel reply;
875 MessageOption option(MessageOption::TF_SYNC);
876 uint32_t code = static_cast<uint32_t>(CMD_ON);
877
878 std::string taskId = "1234";
879 std::string testType = "block";
880 auto callback = std::make_shared<DummyPrintServiceStub>();
881 EXPECT_NE(callback, nullptr);
882 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
883 EXPECT_TRUE(data.WriteString(taskId));
884 EXPECT_TRUE(data.WriteString(testType));
885 EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject().GetRefPtr()));
886
887 auto stub = std::make_shared<MockPrintService>();
888 EXPECT_NE(stub, nullptr);
889 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
890 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
891 }
892
893 /**
894 * @tc.name: PrintServiceStubTest_0036
895 * @tc.desc: Verify the capability function.
896 * @tc.type: FUNC
897 * @tc.require:
898 */
899 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0036, TestSize.Level1)
900 {
901 MessageParcel data;
902 MessageParcel reply;
903 MessageOption option(MessageOption::TF_SYNC);
904 uint32_t code = static_cast<uint32_t>(CMD_OFF);
905
906 std::string taskId = "1234";
907 std::string testType = "block";
908 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
909 EXPECT_TRUE(data.WriteString(taskId));
910 EXPECT_TRUE(data.WriteString(testType));
911
912 auto stub = std::make_shared<MockPrintService>();
913 EXPECT_NE(stub, nullptr);
914 ON_CALL(*stub, Off).WillByDefault(Return(E_PRINT_NONE));
915 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
916 }
917
918 /**
919 * @tc.name: PrintServiceStubTest_0037
920 * @tc.desc: Verify the capability function.
921 * @tc.type: FUNC
922 * @tc.require:
923 */
924 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0037, TestSize.Level1)
925 {
926 MessageParcel data;
927 MessageParcel reply;
928 MessageOption option(MessageOption::TF_SYNC);
929 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
930
931 std::string extensionCid = "com.exmpale.ext:1234";
932 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
933 EXPECT_TRUE(data.WriteString(extensionCid));
934
935 auto stub = std::make_shared<MockPrintService>();
936 EXPECT_NE(stub, nullptr);
937 ON_CALL(*stub, RegisterExtCallback).WillByDefault(Return(E_PRINT_NONE));
938 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
939 }
940
941 /**
942 * @tc.name: PrintServiceStubTest_0038
943 * @tc.desc: Verify the capability function.
944 * @tc.type: FUNC
945 * @tc.require:
946 */
947 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0038, TestSize.Level1)
948 {
949 MessageParcel data;
950 MessageParcel reply;
951 MessageOption option(MessageOption::TF_SYNC);
952 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
953
954 std::string extensionCid = "com.exmpale.ext:1234";
955 auto callback = std::make_shared<DummyPrintServiceStub>();
956 EXPECT_NE(callback, nullptr);
957 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
958 EXPECT_TRUE(data.WriteString(extensionCid));
959 EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject().GetRefPtr()));
960
961 auto stub = std::make_shared<MockPrintService>();
962 EXPECT_NE(stub, nullptr);
963 ON_CALL(*stub, RegisterExtCallback).WillByDefault(Return(E_PRINT_NONE));
964 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
965 }
966
967 /**
968 * @tc.name: PrintServiceStubTest_0039
969 * @tc.desc: Verify the capability function.
970 * @tc.type: FUNC
971 * @tc.require:
972 */
973 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0039, TestSize.Level1)
974 {
975 MessageParcel data;
976 MessageParcel reply;
977 MessageOption option(MessageOption::TF_SYNC);
978 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
979
980 std::string extensionCid = "com.exmpale.ext:1";
981 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
982 EXPECT_TRUE(data.WriteString(extensionCid));
983
984 auto stub = std::make_shared<MockPrintService>();
985 EXPECT_NE(stub, nullptr);
986 ON_CALL(*stub, UnregisterAllExtCallback).WillByDefault(Return(E_PRINT_NONE));
987 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
988 }
989
990 /**
991 * @tc.name: PrintServiceStubTest_0040
992 * @tc.desc: Verify the capability function.
993 * @tc.type: FUNC
994 * @tc.require:
995 */
996 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0040, TestSize.Level1)
997 {
998 MessageParcel data;
999 MessageParcel reply;
1000 MessageOption option(MessageOption::TF_SYNC);
1001 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
1002
1003 std::string extensionId = "com.exmpale.ext";
1004 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1005 EXPECT_TRUE(data.WriteString(extensionId));
1006
1007 auto stub = std::make_shared<MockPrintService>();
1008 EXPECT_NE(stub, nullptr);
1009 ON_CALL(*stub, LoadExtSuccess).WillByDefault(Return(E_PRINT_NONE));
1010 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1011 }
1012
1013 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0041, TestSize.Level1)
1014 {
1015 MessageParcel data;
1016 MessageParcel reply;
1017 MessageOption option(MessageOption::TF_SYNC);
1018 uint32_t code = static_cast<uint32_t>(CMD_UNREG_EXT_CB);
1019
1020 std::string extensionId = "com.exmpale.ext";
1021 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1022 EXPECT_TRUE(data.WriteString(extensionId));
1023
1024 auto stub = std::make_shared<MockPrintService>();
1025 EXPECT_NE(stub, nullptr);
1026 ON_CALL(*stub, UnregisterAllExtCallback).WillByDefault(Return(E_PRINT_NONE));
1027 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1028 }
1029
1030 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0042, TestSize.Level1)
1031 {
1032 MessageParcel addData;
1033 MessageParcel addReply;
1034 MessageOption option(MessageOption::TF_SYNC);
1035 uint32_t addCode = static_cast<uint32_t>(CMD_ADDPRINTERTOCUPS);
1036
1037 std::string printerUri = "ipp://192.168.186.1:631/ipp/print";
1038 std::string printerName = "DIRECT-PixLab_V1-1620";
1039 std::string printerMake = "PixLab V1 - IPP Everywhere";
1040 EXPECT_TRUE(addData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1041 EXPECT_TRUE(addData.WriteString(printerUri));
1042 EXPECT_TRUE(addData.WriteString(printerName));
1043 EXPECT_TRUE(addData.WriteString(printerMake));
1044
1045 auto stub = std::make_shared<MockPrintService>();
1046 EXPECT_NE(stub, nullptr);
1047 ON_CALL(*stub, AddPrinterToCups).WillByDefault(Return(E_PRINT_NONE));
1048 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(addCode, addData, addReply, option)));
1049
1050 MessageParcel delData;
1051 MessageParcel delReply;
1052 uint32_t delCode = static_cast<uint32_t>(CMD_DELETE_PRINTER_FROM_CUPS);
1053
1054 EXPECT_TRUE(delData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1055 EXPECT_TRUE(delData.WriteString(printerName));
1056
1057 ON_CALL(*stub, DeletePrinterFromCups).WillByDefault(Return(E_PRINT_NONE));
1058 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(delCode, delData, delReply, option)));
1059 }
1060
1061 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0043, TestSize.Level1)
1062 {
1063 MessageParcel data;
1064 MessageParcel reply;
1065 MessageOption option(MessageOption::TF_SYNC);
1066 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERCAPABILITYBYURI);
1067
1068 std::string printerUri = "ipp://192.168.186.1:631/ipp/print";
1069 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1070
1071 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1072 EXPECT_TRUE(data.WriteString(printerUri));
1073 EXPECT_TRUE(data.WriteString(printerId));
1074
1075 auto stub = std::make_shared<MockPrintService>();
1076 EXPECT_NE(stub, nullptr);
1077 ON_CALL(*stub, QueryPrinterCapabilityByUri).WillByDefault(Return(E_PRINT_NONE));
1078 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1079 }
1080
1081 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0044, TestSize.Level1)
1082 {
1083 MessageParcel data;
1084 MessageParcel reply;
1085 MessageOption option(MessageOption::TF_SYNC);
1086 uint32_t code = static_cast<uint32_t>(CMD_STARTPRINTJOB_BY_ADAPTER);
1087
1088 std::string jobName = "com.exmpale.ext";
1089 PrintAttributes attr;
1090
1091 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1092 EXPECT_TRUE(data.WriteString(jobName));
1093
1094 auto stub = std::make_shared<MockPrintService>();
1095 EXPECT_NE(stub, nullptr);
1096 ON_CALL(*stub, PrintByAdapter).WillByDefault(Return(E_PRINT_NONE));
1097 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1098 }
1099
1100 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0045, TestSize.Level1)
1101 {
1102 MessageParcel data;
1103 MessageParcel reply;
1104 MessageOption option(MessageOption::TF_SYNC);
1105 uint32_t code = static_cast<uint32_t>(CMD_START_GET_FILE);
1106
1107 std::string jobId = "1";
1108 PrintAttributes attr;
1109 uint32_t fd = 56;
1110 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1111 EXPECT_TRUE(data.WriteString(jobId));
1112 EXPECT_TRUE(data.WriteUint32(fd));
1113
1114 auto stub = std::make_shared<MockPrintService>();
1115 EXPECT_NE(stub, nullptr);
1116 ON_CALL(*stub, StartGetPrintFile).WillByDefault(Return(E_PRINT_NONE));
1117 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1118 }
1119
1120 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0046, TestSize.Level1)
1121 {
1122 MessageParcel data;
1123 MessageParcel reply;
1124 MessageOption option(MessageOption::TF_SYNC);
1125 uint32_t code = static_cast<uint32_t>(CMD_NOTIFY_PRINT_SERVICE);
1126
1127 std::string jobId = "";
1128 std::string type = "";
1129 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1130 EXPECT_TRUE(data.WriteString(jobId));
1131 EXPECT_TRUE(data.WriteString(type));
1132
1133 auto stub = std::make_shared<MockPrintService>();
1134 EXPECT_NE(stub, nullptr);
1135 ON_CALL(*stub, NotifyPrintService).WillByDefault(Return(E_PRINT_NONE));
1136 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1137 }
1138
1139 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0047, TestSize.Level1)
1140 {
1141 MessageParcel data;
1142 MessageParcel reply;
1143 MessageOption option(MessageOption::TF_SYNC);
1144 uint32_t code = static_cast<uint32_t>(CMD_START_NATIVE_PRINT);
1145
1146 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1147
1148 auto stub = std::make_shared<MockPrintService>();
1149 EXPECT_NE(stub, nullptr);
1150 ON_CALL(*stub, StartPrint).WillByDefault(Return(E_PRINT_NONE));
1151 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1152 }
1153
1154 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0048, TestSize.Level1)
1155 {
1156 MessageParcel data;
1157 MessageParcel reply;
1158 MessageOption option(MessageOption::TF_SYNC);
1159 uint32_t code = static_cast<uint32_t>(CMD_START_SERVICE);
1160
1161 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1162
1163 auto stub = std::make_shared<MockPrintService>();
1164 EXPECT_NE(stub, nullptr);
1165 ON_CALL(*stub, StartService).WillByDefault(Return(E_PRINT_NONE));
1166 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1167 }
1168
1169 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0049, TestSize.Level1)
1170 {
1171 MessageParcel data;
1172 MessageParcel reply;
1173 MessageOption option(MessageOption::TF_SYNC);
1174 uint32_t code = static_cast<uint32_t>(CMD_REG_PRINTER_CB);
1175
1176 std::string type = "";
1177 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1178 EXPECT_TRUE(data.WriteString(type));
1179
1180 auto stub = std::make_shared<MockPrintService>();
1181 EXPECT_NE(stub, nullptr);
1182 ON_CALL(*stub, RegisterPrinterCallback).WillByDefault(Return(E_PRINT_NONE));
1183 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1184 }
1185
1186 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0050, TestSize.Level1)
1187 {
1188 MessageParcel data;
1189 MessageParcel reply;
1190 MessageOption option(MessageOption::TF_SYNC);
1191 uint32_t code = static_cast<uint32_t>(CMD_UNREG_PRINTER_CB);
1192
1193 std::string type = "";
1194 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1195 EXPECT_TRUE(data.WriteString(type));
1196
1197 auto stub = std::make_shared<MockPrintService>();
1198 EXPECT_NE(stub, nullptr);
1199 ON_CALL(*stub, UnregisterPrinterCallback).WillByDefault(Return(E_PRINT_NONE));
1200 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1201 }
1202
1203 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0051, TestSize.Level1)
1204 {
1205 MessageParcel data;
1206 MessageParcel reply;
1207 MessageOption option(MessageOption::TF_SYNC);
1208 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERINFOBYPRINTERID);
1209
1210 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1211 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1212 EXPECT_TRUE(data.WriteString(printerId));
1213
1214 auto stub = std::make_shared<MockPrintService>();
1215 EXPECT_NE(stub, nullptr);
1216 ON_CALL(*stub, QueryPrinterInfoByPrinterId).WillByDefault(Return(E_PRINT_NONE));
1217 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1218 }
1219
1220 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0052, TestSize.Level1)
1221 {
1222 MessageParcel data;
1223 MessageParcel reply;
1224 MessageOption option(MessageOption::TF_SYNC);
1225 uint32_t code = static_cast<uint32_t>(CMD_QUERYADDEDPRINTER);
1226
1227 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1228
1229 auto stub = std::make_shared<MockPrintService>();
1230 EXPECT_NE(stub, nullptr);
1231 ON_CALL(*stub, QueryAddedPrinter).WillByDefault(Return(E_PRINT_NONE));
1232 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1233 }
1234
1235 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0053, TestSize.Level1)
1236 {
1237 MessageParcel data;
1238 MessageParcel reply;
1239 MessageOption option(MessageOption::TF_SYNC);
1240 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERPROPERTIES);
1241
1242 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1243 std::vector<std::string> keyList;
1244 keyList.resize(1001);
1245 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1246 EXPECT_TRUE(data.WriteString(printerId));
1247 EXPECT_TRUE(data.WriteStringVector(keyList));
1248
1249 auto stub = std::make_shared<MockPrintService>();
1250 EXPECT_NE(stub, nullptr);
1251 ON_CALL(*stub, QueryPrinterProperties).WillByDefault(Return(E_PRINT_NONE));
1252 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1253 }
1254
1255 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0054, TestSize.Level1)
1256 {
1257 MessageParcel data;
1258 MessageParcel reply;
1259 MessageOption option(MessageOption::TF_SYNC);
1260 uint32_t code = static_cast<uint32_t>(CMD_STARTNATIVEPRINTJOB);
1261
1262 PrintJob testJob;
1263 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1264 EXPECT_TRUE(testJob.Marshalling(data));
1265
1266 auto stub = std::make_shared<MockPrintService>();
1267 EXPECT_NE(stub, nullptr);
1268 ON_CALL(*stub, StartNativePrintJob).WillByDefault(Return(E_PRINT_NONE));
1269 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1270 }
1271
1272 /**
1273 * @tc.name: PrintServiceStubTest_0055
1274 * @tc.desc: Verify the capability function.
1275 * @tc.type: FUNC
1276 * @tc.require:
1277 */
1278 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0055, TestSize.Level1)
1279 {
1280 MessageParcel data;
1281 MessageParcel reply;
1282 MessageOption option(MessageOption::TF_SYNC);
1283 uint32_t code = static_cast<uint32_t>(CMD_START_SERVICE);
1284 data.WriteString("nativePrint");
1285 auto stub = std::make_shared<MockPrintService>();
1286 EXPECT_NE(stub, nullptr);
1287 EXPECT_EQ(stub->OnRemoteRequest(code, data, reply, option), E_PRINT_RPC_FAILURE);
1288 }
1289
1290 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0056, TestSize.Level1)
1291 {
1292 MessageParcel data;
1293 MessageParcel reply;
1294 MessageOption option(MessageOption::TF_SYNC);
1295 uint32_t code = static_cast<uint32_t>(CMD_LOAD_EXT);
1296
1297 std::string extensionId = "com.sample.ext";
1298 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1299 EXPECT_TRUE(data.WriteStringVector(extensionId));
1300
1301 auto stub = std::make_shared<MockPrintService>();
1302 EXPECT_NE(stub, nullptr);
1303 ON_CALL(*stub, LoadExtSuccess).WillByDefault(Return(E_PRINT_NONE));
1304 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1305 }
1306
1307 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0057, TestSize.Level1)
1308 {
1309 MessageParcel setData;
1310 MessageParcel setReply;
1311 MessageOption option(MessageOption::TF_SYNC);
1312 uint32_t setCode = static_cast<uint32_t>(CMD_SET_PRINTER_PREFERENCE);
1313
1314 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1315 std::string printerSetting = R"({"pagesizeId":"","orientation":"","duplex":"","quality":""})";
1316 EXPECT_TRUE(setData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1317 EXPECT_TRUE(setData.WriteString(printerId));
1318 EXPECT_TRUE(setData.WriteString(printerSetting));
1319
1320 auto stub = std::make_shared<MockPrintService>();
1321 EXPECT_NE(stub, nullptr);
1322 ON_CALL(*stub, SetPrinterPreference).WillByDefault(Return(E_PRINT_NONE));
1323 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(setCode, setData, setReply, option)));
1324
1325 MessageParcel getData;
1326 MessageParcel getReply;
1327 uint32_t getCode = static_cast<uint32_t>(CMD_GET_PRINTER_PREFERENCE);
1328
1329 EXPECT_TRUE(getData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1330 EXPECT_TRUE(getData.WriteString(printerId));
1331
1332 ON_CALL(*stub, GetPrinterPreference).WillByDefault(Return(E_PRINT_NONE));
1333 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(getCode, getData, getReply, option)));
1334 }
1335
1336 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0058, TestSize.Level1)
1337 {
1338 MessageParcel data;
1339 MessageParcel reply;
1340 MessageOption option(MessageOption::TF_SYNC);
1341 uint32_t code = static_cast<uint32_t>(CMD_SET_DEFAULT_PRINTERID);
1342
1343 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1344 uint32_t type = 2;
1345 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1346 EXPECT_TRUE(data.WriteString(printerId));
1347 EXPECT_TRUE(data.WriteUint32(type));
1348
1349 auto stub = std::make_shared<MockPrintService>();
1350 EXPECT_NE(stub, nullptr);
1351 ON_CALL(*stub, SetDefaultPrinter).WillByDefault(Return(E_PRINT_NONE));
1352 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1353 }
1354
1355 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0059, TestSize.Level1)
1356 {
1357 MessageParcel data;
1358 MessageParcel reply;
1359 MessageOption option(MessageOption::TF_SYNC);
1360 uint32_t code = static_cast<uint32_t>(CMD_DISCOVER_USB_PRINTERS);
1361
1362 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1363
1364 auto stub = std::make_shared<MockPrintService>();
1365 EXPECT_NE(stub, nullptr);
1366 ON_CALL(*stub, DiscoverUsbPrinters).WillByDefault(Return(E_PRINT_NONE));
1367 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1368 }
1369
1370
1371 /**
1372 * @tc.name: PrintServiceStubTest_0060
1373 * @tc.desc: Verify the capability function.
1374 * @tc.type: FUNC
1375 * @tc.require:
1376 */
1377 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0060, TestSize.Level1)
1378 {
1379 MessageParcel data;
1380 MessageParcel reply;
1381 MessageOption option(MessageOption::TF_SYNC);
1382 uint32_t code = static_cast<uint32_t>(CMD_ADDPRINTERTODISCOVERY);
1383
1384 PrinterInfo testInfo;
1385 std::string testPrinterId = "com.sample.ext:1";
1386 testInfo.SetPrinterId(testPrinterId);
1387
1388 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1389 testInfo.Marshalling(data);
1390
1391 auto stub = std::make_shared<MockPrintService>();
1392 EXPECT_NE(stub, nullptr);
1393 ON_CALL(*stub, AddPrinterToDiscovery).WillByDefault(Return(E_PRINT_NONE));
1394 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1395 }
1396
1397 /**
1398 * @tc.name: PrintServiceStubTest_0061
1399 * @tc.desc: Verify the capability function.
1400 * @tc.type: FUNC
1401 * @tc.require:
1402 */
1403 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0061, TestSize.Level1)
1404 {
1405 MessageParcel data;
1406 MessageParcel reply;
1407 MessageOption option(MessageOption::TF_SYNC);
1408 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERINDISCOVERY);
1409
1410 PrinterInfo testInfo;
1411 std::string testPrinterId = "com.sample.ext:1";
1412 testInfo.SetPrinterId(testPrinterId);
1413
1414 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1415 testInfo.Marshalling(data);
1416
1417 auto stub = std::make_shared<MockPrintService>();
1418 EXPECT_NE(stub, nullptr);
1419 ON_CALL(*stub, UpdatePrinterInDiscovery).WillByDefault(Return(E_PRINT_NONE));
1420 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1421 }
1422
1423
1424 /**
1425 * @tc.name: PrintServiceStubTest_0062
1426 * @tc.desc: Verify the capability function.
1427 * @tc.type: FUNC
1428 * @tc.require:
1429 */
1430 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0062, TestSize.Level1)
1431 {
1432 MessageParcel data;
1433 MessageParcel reply;
1434 MessageOption option(MessageOption::TF_SYNC);
1435 uint32_t code = static_cast<uint32_t>(CMD_REMOVEPRINTERFROMDISCOVERY);
1436
1437 std::string testPrinterId = "com.sample.ext:1";
1438
1439 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1440 EXPECT_TRUE(data.WriteString(testPrinterId));
1441
1442 auto stub = std::make_shared<MockPrintService>();
1443 EXPECT_NE(stub, nullptr);
1444 ON_CALL(*stub, RemovePrinterFromDiscovery).WillByDefault(Return(E_PRINT_NONE));
1445 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1446 }
1447
1448 /**
1449 * @tc.name: PrintServiceStubTest_0063
1450 * @tc.desc: Verify the capability function.
1451 * @tc.type: FUNC
1452 * @tc.require:
1453 */
1454 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0063, TestSize.Level1)
1455 {
1456 MessageParcel data;
1457 MessageParcel reply;
1458 MessageOption option(MessageOption::TF_SYNC);
1459 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERINSYSTEM);
1460
1461 PrinterInfo testInfo;
1462 std::string testPrinterId = "com.sample.ext:1";
1463 testInfo.SetPrinterId(testPrinterId);
1464
1465 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1466 testInfo.Marshalling(data);
1467
1468 auto stub = std::make_shared<MockPrintService>();
1469 EXPECT_NE(stub, nullptr);
1470 ON_CALL(*stub, UpdatePrinterInSystem).WillByDefault(Return(E_PRINT_NONE));
1471 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1472 }
1473
1474 } // namespace Print
1475 } // namespace OHOS
1476
