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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0001, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0002, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0003, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0004, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0005, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0006, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0007, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0008, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0009, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0010, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0011, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0012, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0013, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0014, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0015, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0016, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0017, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0018, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0019, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0020, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0021, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0022, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0023, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0025, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0026, TestSize.Level1)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);
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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0027, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0028, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0029, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0030, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0031, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0032, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0033, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0034, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0035, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0036, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0037, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0038, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0039, TestSize.Level1)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 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0040, TestSize.Level1)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
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0041, TestSize.Level1)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
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0042, TestSize.Level1)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(printerUri));
1056 EXPECT_TRUE(delData.WriteString(printerName));
1057 EXPECT_TRUE(delData.WriteString(printerMake));
1058
1059 ON_CALL(*stub, DeletePrinterFromCups).WillByDefault(Return(E_PRINT_NONE));
1060 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(delCode, delData, delReply, option)));
1061 }
1062
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0043, TestSize.Level1)1063 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0043, TestSize.Level1)
1064 {
1065 MessageParcel data;
1066 MessageParcel reply;
1067 MessageOption option(MessageOption::TF_SYNC);
1068 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERCAPABILITYBYURI);
1069
1070 std::string printerUri = "ipp://192.168.186.1:631/ipp/print";
1071 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1072
1073 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1074 EXPECT_TRUE(data.WriteString(printerUri));
1075 EXPECT_TRUE(data.WriteString(printerId));
1076
1077 auto stub = std::make_shared<MockPrintService>();
1078 EXPECT_NE(stub, nullptr);
1079 ON_CALL(*stub, QueryPrinterCapabilityByUri).WillByDefault(Return(E_PRINT_NONE));
1080 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1081 }
1082
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0044, TestSize.Level1)1083 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0044, TestSize.Level1)
1084 {
1085 MessageParcel data;
1086 MessageParcel reply;
1087 MessageOption option(MessageOption::TF_SYNC);
1088 uint32_t code = static_cast<uint32_t>(CMD_STARTPRINTJOB_BY_ADAPTER);
1089
1090 std::string jobName = "com.exmpale.ext";
1091 PrintAttributes attr;
1092
1093 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1094 EXPECT_TRUE(data.WriteString(jobName));
1095
1096 auto stub = std::make_shared<MockPrintService>();
1097 EXPECT_NE(stub, nullptr);
1098 ON_CALL(*stub, PrintByAdapter).WillByDefault(Return(E_PRINT_NONE));
1099 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1100 }
1101
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0045, TestSize.Level1)1102 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0045, TestSize.Level1)
1103 {
1104 MessageParcel data;
1105 MessageParcel reply;
1106 MessageOption option(MessageOption::TF_SYNC);
1107 uint32_t code = static_cast<uint32_t>(CMD_START_GET_FILE);
1108
1109 std::string jobId = "1";
1110 PrintAttributes attr;
1111 uint32_t fd = 56;
1112 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1113 EXPECT_TRUE(data.WriteString(jobId));
1114 EXPECT_TRUE(data.WriteUint32(fd));
1115
1116 auto stub = std::make_shared<MockPrintService>();
1117 EXPECT_NE(stub, nullptr);
1118 ON_CALL(*stub, StartGetPrintFile).WillByDefault(Return(E_PRINT_NONE));
1119 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1120 }
1121
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0046, TestSize.Level1)1122 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0046, TestSize.Level1)
1123 {
1124 MessageParcel data;
1125 MessageParcel reply;
1126 MessageOption option(MessageOption::TF_SYNC);
1127 uint32_t code = static_cast<uint32_t>(CMD_NOTIFY_PRINT_SERVICE);
1128
1129 std::string jobId = "";
1130 std::string type = "";
1131 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1132 EXPECT_TRUE(data.WriteString(jobId));
1133 EXPECT_TRUE(data.WriteString(type));
1134
1135 auto stub = std::make_shared<MockPrintService>();
1136 EXPECT_NE(stub, nullptr);
1137 ON_CALL(*stub, NotifyPrintService).WillByDefault(Return(E_PRINT_NONE));
1138 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1139 }
1140
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0047, TestSize.Level1)1141 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0047, TestSize.Level1)
1142 {
1143 MessageParcel data;
1144 MessageParcel reply;
1145 MessageOption option(MessageOption::TF_SYNC);
1146 uint32_t code = static_cast<uint32_t>(CMD_START_NATIVE_PRINT);
1147
1148 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1149
1150 auto stub = std::make_shared<MockPrintService>();
1151 EXPECT_NE(stub, nullptr);
1152 ON_CALL(*stub, StartPrint).WillByDefault(Return(E_PRINT_NONE));
1153 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1154 }
1155
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0048, TestSize.Level1)1156 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0048, TestSize.Level1)
1157 {
1158 MessageParcel data;
1159 MessageParcel reply;
1160 MessageOption option(MessageOption::TF_SYNC);
1161 uint32_t code = static_cast<uint32_t>(CMD_START_SERVICE);
1162
1163 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1164
1165 auto stub = std::make_shared<MockPrintService>();
1166 EXPECT_NE(stub, nullptr);
1167 ON_CALL(*stub, StartService).WillByDefault(Return(E_PRINT_NONE));
1168 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1169 }
1170
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0049, TestSize.Level1)1171 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0049, TestSize.Level1)
1172 {
1173 MessageParcel data;
1174 MessageParcel reply;
1175 MessageOption option(MessageOption::TF_SYNC);
1176 uint32_t code = static_cast<uint32_t>(CMD_REG_PRINTER_CB);
1177
1178 std::string type = "";
1179 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1180 EXPECT_TRUE(data.WriteString(type));
1181
1182 auto stub = std::make_shared<MockPrintService>();
1183 EXPECT_NE(stub, nullptr);
1184 ON_CALL(*stub, RegisterPrinterCallback).WillByDefault(Return(E_PRINT_NONE));
1185 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1186 }
1187
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0050, TestSize.Level1)1188 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0050, TestSize.Level1)
1189 {
1190 MessageParcel data;
1191 MessageParcel reply;
1192 MessageOption option(MessageOption::TF_SYNC);
1193 uint32_t code = static_cast<uint32_t>(CMD_UNREG_PRINTER_CB);
1194
1195 std::string type = "";
1196 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1197 EXPECT_TRUE(data.WriteString(type));
1198
1199 auto stub = std::make_shared<MockPrintService>();
1200 EXPECT_NE(stub, nullptr);
1201 ON_CALL(*stub, UnregisterPrinterCallback).WillByDefault(Return(E_PRINT_NONE));
1202 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1203 }
1204
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0051, TestSize.Level1)1205 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0051, TestSize.Level1)
1206 {
1207 MessageParcel data;
1208 MessageParcel reply;
1209 MessageOption option(MessageOption::TF_SYNC);
1210 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERINFOBYPRINTERID);
1211
1212 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1213 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1214 EXPECT_TRUE(data.WriteString(printerId));
1215
1216 auto stub = std::make_shared<MockPrintService>();
1217 EXPECT_NE(stub, nullptr);
1218 ON_CALL(*stub, QueryPrinterInfoByPrinterId).WillByDefault(Return(E_PRINT_NONE));
1219 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1220 }
1221
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0052, TestSize.Level1)1222 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0052, TestSize.Level1)
1223 {
1224 MessageParcel data;
1225 MessageParcel reply;
1226 MessageOption option(MessageOption::TF_SYNC);
1227 uint32_t code = static_cast<uint32_t>(CMD_QUERYADDEDPRINTER);
1228
1229 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1230
1231 auto stub = std::make_shared<MockPrintService>();
1232 EXPECT_NE(stub, nullptr);
1233 ON_CALL(*stub, QueryAddedPrinter).WillByDefault(Return(E_PRINT_NONE));
1234 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1235 }
1236
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0053, TestSize.Level1)1237 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0053, TestSize.Level1)
1238 {
1239 MessageParcel data;
1240 MessageParcel reply;
1241 MessageOption option(MessageOption::TF_SYNC);
1242 uint32_t code = static_cast<uint32_t>(CMD_QUERYPRINTERPROPERTIES);
1243
1244 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1245 std::vector<std::string> keyList;
1246 keyList.resize(1001);
1247 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1248 EXPECT_TRUE(data.WriteString(printerId));
1249 EXPECT_TRUE(data.WriteStringVector(keyList));
1250
1251 auto stub = std::make_shared<MockPrintService>();
1252 EXPECT_NE(stub, nullptr);
1253 ON_CALL(*stub, QueryPrinterProperties).WillByDefault(Return(E_PRINT_NONE));
1254 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1255 }
1256
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0054, TestSize.Level1)1257 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0054, TestSize.Level1)
1258 {
1259 MessageParcel data;
1260 MessageParcel reply;
1261 MessageOption option(MessageOption::TF_SYNC);
1262 uint32_t code = static_cast<uint32_t>(CMD_STARTNATIVEPRINTJOB);
1263
1264 PrintJob testJob;
1265 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1266 EXPECT_TRUE(testJob.Marshalling(data));
1267
1268 auto stub = std::make_shared<MockPrintService>();
1269 EXPECT_NE(stub, nullptr);
1270 ON_CALL(*stub, StartNativePrintJob).WillByDefault(Return(E_PRINT_NONE));
1271 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1272 }
1273
1274 /**
1275 * @tc.name: PrintServiceStubTest_0055
1276 * @tc.desc: Verify the capability function.
1277 * @tc.type: FUNC
1278 * @tc.require:
1279 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0055, TestSize.Level1)1280 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0055, TestSize.Level1)
1281 {
1282 MessageParcel data;
1283 MessageParcel reply;
1284 MessageOption option(MessageOption::TF_SYNC);
1285 uint32_t code = static_cast<uint32_t>(CMD_START_SERVICE);
1286 data.WriteString("nativePrint");
1287 auto stub = std::make_shared<MockPrintService>();
1288 EXPECT_NE(stub, nullptr);
1289 EXPECT_EQ(stub->OnRemoteRequest(code, data, reply, option), E_PRINT_RPC_FAILURE);
1290 }
1291
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0056, TestSize.Level1)1292 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0056, TestSize.Level1)
1293 {
1294 MessageParcel data;
1295 MessageParcel reply;
1296 MessageOption option(MessageOption::TF_SYNC);
1297 uint32_t code = static_cast<uint32_t>(CMD_LOAD_EXT);
1298
1299 std::string extensionId = "com.sample.ext";
1300 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1301 EXPECT_TRUE(data.WriteStringVector(extensionId));
1302
1303 auto stub = std::make_shared<MockPrintService>();
1304 EXPECT_NE(stub, nullptr);
1305 ON_CALL(*stub, LoadExtSuccess).WillByDefault(Return(E_PRINT_NONE));
1306 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1307 }
1308
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0057, TestSize.Level1)1309 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0057, TestSize.Level1)
1310 {
1311 MessageParcel setData;
1312 MessageParcel setReply;
1313 MessageOption option(MessageOption::TF_SYNC);
1314 uint32_t setCode = static_cast<uint32_t>(CMD_SET_PRINTER_PREFERENCE);
1315
1316 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1317 std::string printerSetting = R"({"pagesizeId":"","orientation":"","duplex":"","quality":""})";
1318 EXPECT_TRUE(setData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1319 EXPECT_TRUE(setData.WriteString(printerId));
1320 EXPECT_TRUE(setData.WriteString(printerSetting));
1321
1322 auto stub = std::make_shared<MockPrintService>();
1323 EXPECT_NE(stub, nullptr);
1324 ON_CALL(*stub, SetPrinterPreference).WillByDefault(Return(E_PRINT_NONE));
1325 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(setCode, setData, setReply, option)));
1326
1327 MessageParcel getData;
1328 MessageParcel getReply;
1329 uint32_t getCode = static_cast<uint32_t>(CMD_GET_PRINTER_PREFERENCE);
1330
1331 EXPECT_TRUE(getData.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1332 EXPECT_TRUE(getData.WriteString(printerId));
1333
1334 ON_CALL(*stub, GetPrinterPreference).WillByDefault(Return(E_PRINT_NONE));
1335 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(getCode, getData, getReply, option)));
1336 }
1337
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0058, TestSize.Level1)1338 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0058, TestSize.Level1)
1339 {
1340 MessageParcel data;
1341 MessageParcel reply;
1342 MessageOption option(MessageOption::TF_SYNC);
1343 uint32_t code = static_cast<uint32_t>(CMD_SET_DEFAULT_PRINTERID);
1344
1345 std::string printerId = "com.ohos.spooler:p2p://DIRECT-PixLab_V1-1620";
1346 uint32_t type = 2;
1347 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1348 EXPECT_TRUE(data.WriteString(printerId));
1349 EXPECT_TRUE(data.WriteUint32(type));
1350
1351 auto stub = std::make_shared<MockPrintService>();
1352 EXPECT_NE(stub, nullptr);
1353 ON_CALL(*stub, SetDefaultPrinter).WillByDefault(Return(E_PRINT_NONE));
1354 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1355 }
1356
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0059, TestSize.Level1)1357 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0059, TestSize.Level1)
1358 {
1359 MessageParcel data;
1360 MessageParcel reply;
1361 MessageOption option(MessageOption::TF_SYNC);
1362 uint32_t code = static_cast<uint32_t>(CMD_DISCOVER_USB_PRINTERS);
1363
1364 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1365
1366 auto stub = std::make_shared<MockPrintService>();
1367 EXPECT_NE(stub, nullptr);
1368 ON_CALL(*stub, DiscoverUsbPrinters).WillByDefault(Return(E_PRINT_NONE));
1369 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1370 }
1371
1372
1373 /**
1374 * @tc.name: PrintServiceStubTest_0060
1375 * @tc.desc: Verify the capability function.
1376 * @tc.type: FUNC
1377 * @tc.require:
1378 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0060, TestSize.Level1)1379 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0060, TestSize.Level1)
1380 {
1381 MessageParcel data;
1382 MessageParcel reply;
1383 MessageOption option(MessageOption::TF_SYNC);
1384 uint32_t code = static_cast<uint32_t>(CMD_ADDPRINTERTODISCOVERY);
1385
1386 PrinterInfo testInfo;
1387 std::string testPrinterId = "com.sample.ext:1";
1388 testInfo.SetPrinterId(testPrinterId);
1389
1390 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1391 testInfo.Marshalling(data);
1392
1393 auto stub = std::make_shared<MockPrintService>();
1394 EXPECT_NE(stub, nullptr);
1395 ON_CALL(*stub, AddPrinterToDiscovery).WillByDefault(Return(E_PRINT_NONE));
1396 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1397 }
1398
1399 /**
1400 * @tc.name: PrintServiceStubTest_0061
1401 * @tc.desc: Verify the capability function.
1402 * @tc.type: FUNC
1403 * @tc.require:
1404 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0061, TestSize.Level1)1405 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0061, TestSize.Level1)
1406 {
1407 MessageParcel data;
1408 MessageParcel reply;
1409 MessageOption option(MessageOption::TF_SYNC);
1410 uint32_t code = static_cast<uint32_t>(CMD_UPDATEPRINTERINDISCOVERY);
1411
1412 PrinterInfo testInfo;
1413 std::string testPrinterId = "com.sample.ext:1";
1414 testInfo.SetPrinterId(testPrinterId);
1415
1416 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1417 testInfo.Marshalling(data);
1418
1419 auto stub = std::make_shared<MockPrintService>();
1420 EXPECT_NE(stub, nullptr);
1421 ON_CALL(*stub, UpdatePrinterInDiscovery).WillByDefault(Return(E_PRINT_NONE));
1422 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1423 }
1424
1425
1426 /**
1427 * @tc.name: PrintServiceStubTest_0062
1428 * @tc.desc: Verify the capability function.
1429 * @tc.type: FUNC
1430 * @tc.require:
1431 */
HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0062, TestSize.Level1)1432 HWTEST_F(PrintServiceStubTest, PrintServiceStubTest_0062, TestSize.Level1)
1433 {
1434 MessageParcel data;
1435 MessageParcel reply;
1436 MessageOption option(MessageOption::TF_SYNC);
1437 uint32_t code = static_cast<uint32_t>(CMD_REMOVEPRINTERFROMDISCOVERY);
1438
1439 std::string testPrinterId = "com.sample.ext:1";
1440
1441 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
1442 EXPECT_TRUE(data.WriteString(testPrinterId));
1443
1444 auto stub = std::make_shared<MockPrintService>();
1445 EXPECT_NE(stub, nullptr);
1446 ON_CALL(*stub, RemovePrinterFromDiscovery).WillByDefault(Return(E_PRINT_NONE));
1447 EXPECT_TRUE(static_cast<bool>(stub->OnRemoteRequest(code, data, reply, option)));
1448 }
1449
1450 } // namespace Print
1451 } // namespace OHOS
1452
