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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
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_NeedRename, TestSize.Level0)
750 {
751 MessageParcel data;
752 MessageParcel reply;
753 MessageOption option(MessageOption::TF_SYNC);
754 uint32_t code = static_cast<uint32_t>(CMD_QUERYALLACTIVEPRINTJOB);
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, QueryAllActivePrintJob).WillByDefault(Return(E_PRINT_NONE));
761 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
762 }
763
764 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0065_NeedRename, TestSize.Level0)
765 {
766 MessageParcel data;
767 MessageParcel reply;
768 MessageOption option(MessageOption::TF_SYNC);
769 uint32_t code = static_cast<uint32_t>(CMD_QUERYALLPRINTJOB);
770
771 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
772
773 auto stub = std::make_shared<MockPrintService>();
774 EXPECT_NE(stub, nullptr);
775 ON_CALL(*stub, QueryAllPrintJob).WillByDefault(Return(E_PRINT_NONE));
776 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
777 }
778 /**
779 * @tc.name: PrintServiceStubTest_0031
780 * @tc.desc: Verify the capability function.
781 * @tc.type: FUNC
782 * @tc.require:
783 */
784 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0031_NeedRename, TestSize.Level0)
785 {
786 MessageParcel data;
787 MessageParcel reply;
788 MessageOption option(MessageOption::TF_SYNC);
789 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTJOBBYID);
790
791 std::string jobId = "job:1234";
792 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
793 EXPECT_TRUE(data.WriteString(jobId));
794
795 auto stub = std::make_shared<MockPrintService>();
796 EXPECT_NE(stub, nullptr);
797 ON_CALL(*stub, QueryPrintJobById).WillByDefault(Return(E_PRINT_NONE));
798 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
799 }
800
801 /**
802 * @tc.name: PrintServiceStubTest_0032
803 * @tc.desc: Verify the capability function.
804 * @tc.type: FUNC
805 * @tc.require:
806 */
807 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0032_NeedRename, TestSize.Level0)
808 {
809 MessageParcel data;
810 MessageParcel reply;
811 MessageOption option(MessageOption::TF_SYNC);
812 uint32_t code = static_cast<uint32_t>(CMD_ON);
813
814 std::string taskId = "1234";
815 std::string testType = "";
816 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
817 EXPECT_TRUE(data.WriteString(taskId));
818 EXPECT_TRUE(data.WriteString(testType));
819
820 auto stub = std::make_shared<MockPrintService>();
821 EXPECT_NE(stub, nullptr);
822 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
823 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
824 }
825
826 /**
827 * @tc.name: PrintServiceStubTest_0033
828 * @tc.desc: Verify the capability function.
829 * @tc.type: FUNC
830 * @tc.require:
831 */
832 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0033_NeedRename, TestSize.Level0)
833 {
834 MessageParcel data;
835 MessageParcel reply;
836 MessageOption option(MessageOption::TF_SYNC);
837 uint32_t code = static_cast<uint32_t>(CMD_ON);
838
839 std::string taskId = "1234";
840 std::string testType = "block";
841 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
842 EXPECT_TRUE(data.WriteString(taskId));
843 EXPECT_TRUE(data.WriteString(testType));
844
845 auto stub = std::make_shared<MockPrintService>();
846 EXPECT_NE(stub, nullptr);
847 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
848 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
849 }
850
851 /**
852 * @tc.name: PrintServiceStubTest_0034
853 * @tc.desc: Verify the capability function.
854 * @tc.type: FUNC
855 * @tc.require:
856 */
857 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0034_NeedRename, TestSize.Level0)
858 {
859 MessageParcel data;
860 MessageParcel reply;
861 MessageOption option(MessageOption::TF_SYNC);
862 uint32_t code = static_cast<uint32_t>(CMD_ON);
863
864 std::string taskId = "1234";
865 std::string testType = "block";
866 auto callback = std::make_shared<PrintExtensionCallbackStub>();
867 EXPECT_NE(callback, nullptr);
868 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
869 EXPECT_TRUE(data.WriteString(taskId));
870 EXPECT_TRUE(data.WriteString(testType));
871 EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject().GetRefPtr()));
872
873 auto stub = std::make_shared<MockPrintService>();
874 EXPECT_NE(stub, nullptr);
875 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
876 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
877 }
878
879 /**
880 * @tc.name: PrintServiceStubTest_0035
881 * @tc.desc: Verify the capability function.
882 * @tc.type: FUNC
883 * @tc.require:
884 */
885 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0035_NeedRename, TestSize.Level0)
886 {
887 MessageParcel data;
888 MessageParcel reply;
889 MessageOption option(MessageOption::TF_SYNC);
890 uint32_t code = static_cast<uint32_t>(CMD_ON);
891
892 std::string taskId = "1234";
893 std::string testType = "block";
894 auto callback = std::make_shared<DummyPrintServiceStub>();
895 EXPECT_NE(callback, nullptr);
896 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
897 EXPECT_TRUE(data.WriteString(taskId));
898 EXPECT_TRUE(data.WriteString(testType));
899 EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject().GetRefPtr()));
900
901 auto stub = std::make_shared<MockPrintService>();
902 EXPECT_NE(stub, nullptr);
903 ON_CALL(*stub, On).WillByDefault(Return(E_PRINT_NONE));
904 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
905 }
906
907 /**
908 * @tc.name: PrintServiceStubTest_0036
909 * @tc.desc: Verify the capability function.
910 * @tc.type: FUNC
911 * @tc.require:
912 */
913 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0036_NeedRename, TestSize.Level0)
914 {
915 MessageParcel data;
916 MessageParcel reply;
917 MessageOption option(MessageOption::TF_SYNC);
918 uint32_t code = static_cast<uint32_t>(CMD_OFF);
919
920 std::string taskId = "1234";
921 std::string testType = "block";
922 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
923 EXPECT_TRUE(data.WriteString(taskId));
924 EXPECT_TRUE(data.WriteString(testType));
925
926 auto stub = std::make_shared<MockPrintService>();
927 EXPECT_NE(stub, nullptr);
928 ON_CALL(*stub, Off).WillByDefault(Return(E_PRINT_NONE));
929 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
930 }
931
932 /**
933 * @tc.name: PrintServiceStubTest_0037
934 * @tc.desc: Verify the capability function.
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0037_NeedRename, TestSize.Level0)
939 {
940 MessageParcel data;
941 MessageParcel reply;
942 MessageOption option(MessageOption::TF_SYNC);
943 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
944
945 std::string extensionCid = "com.exmpale.ext:1234";
946 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
947 EXPECT_TRUE(data.WriteString(extensionCid));
948
949 auto stub = std::make_shared<MockPrintService>();
950 EXPECT_NE(stub, nullptr);
951 ON_CALL(*stub, RegisterExtCallback).WillByDefault(Return(E_PRINT_NONE));
952 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
953 }
954
955 /**
956 * @tc.name: PrintServiceStubTest_0038
957 * @tc.desc: Verify the capability function.
958 * @tc.type: FUNC
959 * @tc.require:
960 */
961 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0038_NeedRename, TestSize.Level0)
962 {
963 MessageParcel data;
964 MessageParcel reply;
965 MessageOption option(MessageOption::TF_SYNC);
966 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
967
968 std::string extensionCid = "com.exmpale.ext:1234";
969 auto callback = std::make_shared<DummyPrintServiceStub>();
970 EXPECT_NE(callback, nullptr);
971 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
972 EXPECT_TRUE(data.WriteString(extensionCid));
973 EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject().GetRefPtr()));
974
975 auto stub = std::make_shared<MockPrintService>();
976 EXPECT_NE(stub, nullptr);
977 ON_CALL(*stub, RegisterExtCallback).WillByDefault(Return(E_PRINT_NONE));
978 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
979 }
980
981 /**
982 * @tc.name: PrintServiceStubTest_0039
983 * @tc.desc: Verify the capability function.
984 * @tc.type: FUNC
985 * @tc.require:
986 */
987 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0039_NeedRename, TestSize.Level0)
988 {
989 MessageParcel data;
990 MessageParcel reply;
991 MessageOption option(MessageOption::TF_SYNC);
992 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
993
994 std::string extensionCid = "com.exmpale.ext:1";
995 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
996 EXPECT_TRUE(data.WriteString(extensionCid));
997
998 auto stub = std::make_shared<MockPrintService>();
999 EXPECT_NE(stub, nullptr);
1000 ON_CALL(*stub, UnregisterAllExtCallback).WillByDefault(Return(E_PRINT_NONE));
1001 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1002 }
1003
1004 /**
1005 * @tc.name: PrintServiceStubTest_0040
1006 * @tc.desc: Verify the capability function.
1007 * @tc.type: FUNC
1008 * @tc.require:
1009 */
1010 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0040_NeedRename, TestSize.Level0)
1011 {
1012 MessageParcel data;
1013 MessageParcel reply;
1014 MessageOption option(MessageOption::TF_SYNC);
1015 uint32_t code = static_cast<uint32_t>(CMD_REG_EXT_CB);
1016
1017 std::string extensionId = "com.exmpale.ext";
1018 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1019 EXPECT_TRUE(data.WriteString(extensionId));
1020
1021 auto stub = std::make_shared<MockPrintService>();
1022 EXPECT_NE(stub, nullptr);
1023 ON_CALL(*stub, LoadExtSuccess).WillByDefault(Return(E_PRINT_NONE));
1024 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1025 }
1026
1027 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0041_NeedRename, TestSize.Level0)
1028 {
1029 MessageParcel data;
1030 MessageParcel reply;
1031 MessageOption option(MessageOption::TF_SYNC);
1032 uint32_t code = static_cast<uint32_t>(CMD_UNREG_EXT_CB);
1033
1034 std::string extensionId = "com.exmpale.ext";
1035 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1036 EXPECT_TRUE(data.WriteString(extensionId));
1037
1038 auto stub = std::make_shared<MockPrintService>();
1039 EXPECT_NE(stub, nullptr);
1040 ON_CALL(*stub, UnregisterAllExtCallback).WillByDefault(Return(E_PRINT_NONE));
1041 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1042 }
1043
1044 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0042_NeedRename, TestSize.Level0)
1045 {
1046 MessageParcel addData;
1047 MessageParcel addReply;
1048 MessageOption option(MessageOption::TF_SYNC);
1049 uint32_t addCode = static_cast<uint32_t>(CMD_ADDPRINTERTOCUPS);
1050
1051 std::string printerUri = "ipp://192.168.186.1:631/ipp/print";
1052 std::string printerName = "DIRECT-PixLab_V1-1620";
1053 std::string printerMake = "PixLab V1 - IPP Everywhere";
1054 EXPECT_TRUE(addData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1055 EXPECT_TRUE(addData.WriteString(printerUri));
1056 EXPECT_TRUE(addData.WriteString(printerName));
1057 EXPECT_TRUE(addData.WriteString(printerMake));
1058
1059 auto stub = std::make_shared<MockPrintService>();
1060 EXPECT_NE(stub, nullptr);
1061 ON_CALL(*stub, AddPrinterToCups).WillByDefault(Return(E_PRINT_NONE));
1062 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(addCode, addData, addReply, option)));
1063
1064 MessageParcel delData;
1065 MessageParcel delReply;
1066 uint32_t delCode = static_cast<uint32_t>(CMD_DELETE_PRINTER_FROM_CUPS);
1067
1068 EXPECT_TRUE(delData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1069 EXPECT_TRUE(delData.WriteString(printerName));
1070
1071 ON_CALL(*stub, DeletePrinterFromCups).WillByDefault(Return(E_PRINT_NONE));
1072 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(delCode, delData, delReply, option)));
1073 }
1074
1075 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0043_NeedRename, TestSize.Level0)
1076 {
1077 MessageParcel data;
1078 MessageParcel reply;
1079 MessageOption option(MessageOption::TF_SYNC);
1080 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERCAPABILITYBYURI);
1081
1082 std::string printerUri = "ipp://192.168.186.1:631/ipp/print";
1083 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1084
1085 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1086 EXPECT_TRUE(data.WriteString(printerUri));
1087 EXPECT_TRUE(data.WriteString(printerId));
1088
1089 auto stub = std::make_shared<MockPrintService>();
1090 EXPECT_NE(stub, nullptr);
1091 ON_CALL(*stub, QueryPrinterCapabilityByUri).WillByDefault(Return(E_PRINT_NONE));
1092 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1093 }
1094
1095 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0044_NeedRename, TestSize.Level0)
1096 {
1097 MessageParcel data;
1098 MessageParcel reply;
1099 MessageOption option(MessageOption::TF_SYNC);
1100 uint32_t code = static_cast<uint32_t>(CMD_STARTPRINTJOB_BY_ADAPTER);
1101
1102 std::string jobName = "com.exmpale.ext";
1103 PrintAttributes attr;
1104
1105 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1106 EXPECT_TRUE(data.WriteString(jobName));
1107
1108 auto stub = std::make_shared<MockPrintService>();
1109 EXPECT_NE(stub, nullptr);
1110 ON_CALL(*stub, PrintByAdapter).WillByDefault(Return(E_PRINT_NONE));
1111 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1112 }
1113
1114 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0045_NeedRename, TestSize.Level0)
1115 {
1116 MessageParcel data;
1117 MessageParcel reply;
1118 MessageOption option(MessageOption::TF_SYNC);
1119 uint32_t code = static_cast<uint32_t>(CMD_START_GET_FILE);
1120
1121 std::string jobId = "1";
1122 PrintAttributes attr;
1123 uint32_t fd = 56;
1124 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1125 EXPECT_TRUE(data.WriteString(jobId));
1126 EXPECT_TRUE(data.WriteUint32(fd));
1127
1128 auto stub = std::make_shared<MockPrintService>();
1129 EXPECT_NE(stub, nullptr);
1130 ON_CALL(*stub, StartGetPrintFile).WillByDefault(Return(E_PRINT_NONE));
1131 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1132 }
1133
1134 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0046_NeedRename, TestSize.Level0)
1135 {
1136 MessageParcel data;
1137 MessageParcel reply;
1138 MessageOption option(MessageOption::TF_SYNC);
1139 uint32_t code = static_cast<uint32_t>(CMD_NOTIFY_PRINT_SERVICE);
1140
1141 std::string jobId = "";
1142 std::string type = "";
1143 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1144 EXPECT_TRUE(data.WriteString(jobId));
1145 EXPECT_TRUE(data.WriteString(type));
1146
1147 auto stub = std::make_shared<MockPrintService>();
1148 EXPECT_NE(stub, nullptr);
1149 ON_CALL(*stub, NotifyPrintService).WillByDefault(Return(E_PRINT_NONE));
1150 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1151 }
1152
1153 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0047_NeedRename, TestSize.Level0)
1154 {
1155 MessageParcel data;
1156 MessageParcel reply;
1157 MessageOption option(MessageOption::TF_SYNC);
1158 uint32_t code = static_cast<uint32_t>(CMD_START_NATIVE_PRINT);
1159
1160 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1161
1162 auto stub = std::make_shared<MockPrintService>();
1163 EXPECT_NE(stub, nullptr);
1164 ON_CALL(*stub, StartPrint).WillByDefault(Return(E_PRINT_NONE));
1165 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1166 }
1167
1168 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0048_NeedRename, TestSize.Level0)
1169 {
1170 MessageParcel data;
1171 MessageParcel reply;
1172 MessageOption option(MessageOption::TF_SYNC);
1173 uint32_t code = static_cast<uint32_t>(CMD_START_SERVICE);
1174
1175 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1176
1177 auto stub = std::make_shared<MockPrintService>();
1178 EXPECT_NE(stub, nullptr);
1179 ON_CALL(*stub, StartService).WillByDefault(Return(E_PRINT_NONE));
1180 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1181 }
1182
1183 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0049_NeedRename, TestSize.Level0)
1184 {
1185 MessageParcel data;
1186 MessageParcel reply;
1187 MessageOption option(MessageOption::TF_SYNC);
1188 uint32_t code = static_cast<uint32_t>(CMD_REG_PRINTER_CB);
1189
1190 std::string type = "";
1191 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1192 EXPECT_TRUE(data.WriteString(type));
1193
1194 auto stub = std::make_shared<MockPrintService>();
1195 EXPECT_NE(stub, nullptr);
1196 ON_CALL(*stub, RegisterPrinterCallback).WillByDefault(Return(E_PRINT_NONE));
1197 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1198 }
1199
1200 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0050_NeedRename, TestSize.Level0)
1201 {
1202 MessageParcel data;
1203 MessageParcel reply;
1204 MessageOption option(MessageOption::TF_SYNC);
1205 uint32_t code = static_cast<uint32_t>(CMD_UNREG_PRINTER_CB);
1206
1207 std::string type = "";
1208 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1209 EXPECT_TRUE(data.WriteString(type));
1210
1211 auto stub = std::make_shared<MockPrintService>();
1212 EXPECT_NE(stub, nullptr);
1213 ON_CALL(*stub, UnregisterPrinterCallback).WillByDefault(Return(E_PRINT_NONE));
1214 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1215 }
1216
1217 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0051_NeedRename, TestSize.Level0)
1218 {
1219 MessageParcel data;
1220 MessageParcel reply;
1221 MessageOption option(MessageOption::TF_SYNC);
1222 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERINFOBYPRINTERID);
1223
1224 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1225 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1226 EXPECT_TRUE(data.WriteString(printerId));
1227
1228 auto stub = std::make_shared<MockPrintService>();
1229 EXPECT_NE(stub, nullptr);
1230 ON_CALL(*stub, QueryPrinterInfoByPrinterId).WillByDefault(Return(E_PRINT_NONE));
1231 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1232 }
1233
1234 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0052_NeedRename, TestSize.Level0)
1235 {
1236 MessageParcel data;
1237 MessageParcel reply;
1238 MessageOption option(MessageOption::TF_SYNC);
1239 uint32_t code = static_cast<uint32_t>(CMD_QUERYADDEDPRINTER);
1240
1241 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1242
1243 auto stub = std::make_shared<MockPrintService>();
1244 EXPECT_NE(stub, nullptr);
1245 ON_CALL(*stub, QueryAddedPrinter).WillByDefault(Return(E_PRINT_NONE));
1246 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1247 }
1248
1249 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0053_NeedRename, TestSize.Level0)
1250 {
1251 MessageParcel data;
1252 MessageParcel reply;
1253 MessageOption option(MessageOption::TF_SYNC);
1254 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERPROPERTIES);
1255
1256 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1257 std::vector<std::string> keyList;
1258 keyList.resize(1001);
1259 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1260 EXPECT_TRUE(data.WriteString(printerId));
1261 EXPECT_TRUE(data.WriteStringVector(keyList));
1262
1263 auto stub = std::make_shared<MockPrintService>();
1264 EXPECT_NE(stub, nullptr);
1265 ON_CALL(*stub, QueryPrinterProperties).WillByDefault(Return(E_PRINT_NONE));
1266 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1267 }
1268
1269 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0054_NeedRename, TestSize.Level0)
1270 {
1271 MessageParcel data;
1272 MessageParcel reply;
1273 MessageOption option(MessageOption::TF_SYNC);
1274 uint32_t code = static_cast<uint32_t>(CMD_STARTNATIVEPRINTJOB);
1275
1276 PrintJob testJob;
1277 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1278 EXPECT_TRUE(testJob.Marshalling(data));
1279
1280 auto stub = std::make_shared<MockPrintService>();
1281 EXPECT_NE(stub, nullptr);
1282 ON_CALL(*stub, StartNativePrintJob).WillByDefault(Return(E_PRINT_NONE));
1283 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1284 }
1285
1286 /**
1287 * @tc.name: PrintServiceStubTest_0055
1288 * @tc.desc: Verify the capability function.
1289 * @tc.type: FUNC
1290 * @tc.require:
1291 */
1292 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0055_NeedRename, TestSize.Level0)
1293 {
1294 MessageParcel data;
1295 MessageParcel reply;
1296 MessageOption option(MessageOption::TF_SYNC);
1297 uint32_t code = static_cast<uint32_t>(CMD_START_SERVICE);
1298 data.WriteString("nativePrint");
1299 auto stub = std::make_shared<MockPrintService>();
1300 EXPECT_NE(stub, nullptr);
1301 EXPECT_EQ(stub->OnRemoteRequest(code, data, reply, option), E_PRINT_RPC_FAILURE);
1302 }
1303
1304 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0056_NeedRename, TestSize.Level0)
1305 {
1306 MessageParcel data;
1307 MessageParcel reply;
1308 MessageOption option(MessageOption::TF_SYNC);
1309 uint32_t code = static_cast<uint32_t>(CMD_LOAD_EXT);
1310
1311 std::string extensionId = "com.sample.ext";
1312 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1313 EXPECT_TRUE(data.WriteStringVector(extensionId));
1314
1315 auto stub = std::make_shared<MockPrintService>();
1316 EXPECT_NE(stub, nullptr);
1317 ON_CALL(*stub, LoadExtSuccess).WillByDefault(Return(E_PRINT_NONE));
1318 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1319 }
1320
1321 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0057_NeedRename, TestSize.Level0)
1322 {
1323 MessageParcel setData;
1324 MessageParcel setReply;
1325 MessageOption option(MessageOption::TF_SYNC);
1326 uint32_t setCode = static_cast<uint32_t>(CMD_SET_PRINTER_PREFERENCE);
1327
1328 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1329 std::string printerSetting = R"({"pagesizeId":"","orientation":"","duplex":"","quality":""})";
1330 EXPECT_TRUE(setData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1331 EXPECT_TRUE(setData.WriteString(printerId));
1332 EXPECT_TRUE(setData.WriteString(printerSetting));
1333
1334 auto stub = std::make_shared<MockPrintService>();
1335 EXPECT_NE(stub, nullptr);
1336 ON_CALL(*stub, SetPrinterPreference).WillByDefault(Return(E_PRINT_NONE));
1337 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(setCode, setData, setReply, option)));
1338
1339 MessageParcel getData;
1340 MessageParcel getReply;
1341 uint32_t getCode = static_cast<uint32_t>(CMD_GET_PRINTER_PREFERENCE);
1342
1343 EXPECT_TRUE(getData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1344 EXPECT_TRUE(getData.WriteString(printerId));
1345
1346 ON_CALL(*stub, GetPrinterPreference).WillByDefault(Return(E_PRINT_NONE));
1347 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(getCode, getData, getReply, option)));
1348 }
1349
1350 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0058_NeedRename, TestSize.Level0)
1351 {
1352 MessageParcel data;
1353 MessageParcel reply;
1354 MessageOption option(MessageOption::TF_SYNC);
1355 uint32_t code = static_cast<uint32_t>(CMD_SET_DEFAULT_PRINTERID);
1356
1357 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1358 uint32_t type = 2;
1359 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1360 EXPECT_TRUE(data.WriteString(printerId));
1361 EXPECT_TRUE(data.WriteUint32(type));
1362
1363 auto stub = std::make_shared<MockPrintService>();
1364 EXPECT_NE(stub, nullptr);
1365 ON_CALL(*stub, SetDefaultPrinter).WillByDefault(Return(E_PRINT_NONE));
1366 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1367 }
1368
1369 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0059_NeedRename, TestSize.Level0)
1370 {
1371 MessageParcel data;
1372 MessageParcel reply;
1373 MessageOption option(MessageOption::TF_SYNC);
1374 uint32_t code = static_cast<uint32_t>(CMD_DISCOVER_USB_PRINTERS);
1375
1376 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1377
1378 auto stub = std::make_shared<MockPrintService>();
1379 EXPECT_NE(stub, nullptr);
1380 ON_CALL(*stub, DiscoverUsbPrinters).WillByDefault(Return(E_PRINT_NONE));
1381 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1382 }
1383
1384
1385 /**
1386 * @tc.name: PrintServiceStubTest_0060
1387 * @tc.desc: Verify the capability function.
1388 * @tc.type: FUNC
1389 * @tc.require:
1390 */
1391 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0060_NeedRename, TestSize.Level0)
1392 {
1393 MessageParcel data;
1394 MessageParcel reply;
1395 MessageOption option(MessageOption::TF_SYNC);
1396 uint32_t code = static_cast<uint32_t>(CMD_ADDPRINTERTODISCOVERY);
1397
1398 PrinterInfo testInfo;
1399 std::string testPrinterId = "com.sample.ext:1";
1400 testInfo.SetPrinterId(testPrinterId);
1401
1402 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1403 testInfo.Marshalling(data);
1404
1405 auto stub = std::make_shared<MockPrintService>();
1406 EXPECT_NE(stub, nullptr);
1407 ON_CALL(*stub, AddPrinterToDiscovery).WillByDefault(Return(E_PRINT_NONE));
1408 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1409 }
1410
1411 /**
1412 * @tc.name: PrintServiceStubTest_0061
1413 * @tc.desc: Verify the capability function.
1414 * @tc.type: FUNC
1415 * @tc.require:
1416 */
1417 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0061_NeedRename, TestSize.Level0)
1418 {
1419 MessageParcel data;
1420 MessageParcel reply;
1421 MessageOption option(MessageOption::TF_SYNC);
1422 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERINDISCOVERY);
1423
1424 PrinterInfo testInfo;
1425 std::string testPrinterId = "com.sample.ext:1";
1426 testInfo.SetPrinterId(testPrinterId);
1427
1428 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1429 testInfo.Marshalling(data);
1430
1431 auto stub = std::make_shared<MockPrintService>();
1432 EXPECT_NE(stub, nullptr);
1433 ON_CALL(*stub, UpdatePrinterInDiscovery).WillByDefault(Return(E_PRINT_NONE));
1434 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1435 }
1436
1437
1438 /**
1439 * @tc.name: PrintServiceStubTest_0062
1440 * @tc.desc: Verify the capability function.
1441 * @tc.type: FUNC
1442 * @tc.require:
1443 */
1444 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0062_NeedRename, TestSize.Level0)
1445 {
1446 MessageParcel data;
1447 MessageParcel reply;
1448 MessageOption option(MessageOption::TF_SYNC);
1449 uint32_t code = static_cast<uint32_t>(CMD_REMOVEPRINTERFROMDISCOVERY);
1450
1451 std::string testPrinterId = "com.sample.ext:1";
1452
1453 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1454 EXPECT_TRUE(data.WriteString(testPrinterId));
1455
1456 auto stub = std::make_shared<MockPrintService>();
1457 EXPECT_NE(stub, nullptr);
1458 ON_CALL(*stub, RemovePrinterFromDiscovery).WillByDefault(Return(E_PRINT_NONE));
1459 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1460 }
1461
1462 /**
1463 * @tc.name: PrintServiceStubTest_0063
1464 * @tc.desc: Verify the capability function.
1465 * @tc.type: FUNC
1466 * @tc.require:
1467 */
1468 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0063_NeedRename, TestSize.Level0)
1469 {
1470 MessageParcel data;
1471 MessageParcel reply;
1472 MessageOption option(MessageOption::TF_SYNC);
1473 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERINSYSTEM);
1474
1475 PrinterInfo testInfo;
1476 std::string testPrinterId = "com.sample.ext:1";
1477 testInfo.SetPrinterId(testPrinterId);
1478
1479 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1480 testInfo.Marshalling(data);
1481
1482 auto stub = std::make_shared<MockPrintService>();
1483 EXPECT_NE(stub, nullptr);
1484 ON_CALL(*stub, UpdatePrinterInSystem).WillByDefault(Return(E_PRINT_NONE));
1485 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1486 }
1487
1488 } // namespace Print
1489 } // namespace OHOS
1490
