1 /*
2 * Copyright (c) 2021 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 <memory>
18 #define private public
19 #include "print_manager_client.h"
20 #undef private
21
22 #include "iservice_registry.h"
23 #include "print_constant.h"
24 #include "print_extension_callback_stub.h"
25 #include "print_log.h"
26 #include "print_sync_load_callback.h"
27 #include "system_ability_definition.h"
28 #include "mock_print_service.h"
29 #include "mock_remote_object.h"
30 #include "mock_print_callback_stub.h"
31 #include "mock_print_manager_client.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace Print {
38 class PrintManagerClientTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 void CallRemoteObject(const std::shared_ptr<MockPrintService> service,
45 const sptr<MockRemoteObject> &obj, sptr<IRemoteObject::DeathRecipient> &dr);
46 };
47
SetUpTestCase(void)48 void PrintManagerClientTest::SetUpTestCase(void) {}
49
TearDownTestCase(void)50 void PrintManagerClientTest::TearDownTestCase(void) {}
51
SetUp(void)52 void PrintManagerClientTest::SetUp(void) {}
53
TearDown(void)54 void PrintManagerClientTest::TearDown(void) {}
55
CallRemoteObject(const std::shared_ptr<MockPrintService> service,const sptr<MockRemoteObject> & obj,sptr<IRemoteObject::DeathRecipient> & dr)56 void PrintManagerClientTest::CallRemoteObject(const std::shared_ptr<MockPrintService> service,
57 const sptr<MockRemoteObject> &obj, sptr<IRemoteObject::DeathRecipient> &dr)
58 {
59 EXPECT_NE(obj, nullptr);
60 EXPECT_CALL(*obj, IsProxyObject()).WillRepeatedly(Return(true));
61 EXPECT_CALL(*obj, RemoveDeathRecipient(_)).WillRepeatedly(Return(true));
62 EXPECT_CALL(*obj, AddDeathRecipient(_)).WillRepeatedly(
63 [&dr](const sptr<IRemoteObject::DeathRecipient> &recipient) {
64 dr = recipient;
65 return true;
66 });
67 PrintManagerClient::GetInstance()->SetProxy(obj);
68 EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
69 ON_CALL(*obj, SendRequest)
70 .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
71 service->OnRemoteRequest(code, data, reply, option);
72 return E_PRINT_NONE;
73 });
74 }
75
76 /**
77 * @tc.name: PrintManagerClientTest_0001
78 * @tc.desc: StartPrint failed case.
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0001, TestSize.Level1)
83 {
84 PrintManagerClient::GetInstance()->LoadServerFail();
85 EXPECT_EQ(PrintManagerClient::GetInstance()->ready_, false);
86 }
87
88 /**
89 * @tc.name: PrintManagerClientTest_0002
90 * @tc.desc: StartPrint failed case.
91 * @tc.type: FUNC
92 * @tc.require:
93 */
94 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0002, TestSize.Level1)
95 {
96 std::vector<std::string> testFileList = {"file://data/print/a.png",
97 "file://data/print/b.png", "file://data/print/c.png"};
98 std::vector<uint32_t> testFdList = {1, 2};
99 std::string testTaskId = "2";
100
101 PrintManagerClient::GetInstance()->LoadServerSuccess();
102 PrintManagerClient::GetInstance()->ResetProxy();
103 PrintManagerClient::GetInstance()->StartPrint(testFileList, testFdList, testTaskId);
104 }
105
106 /**
107 * @tc.name: PrintManagerClientTest_0003
108 * @tc.desc: StartPrint failed case.
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0003, TestSize.Level1)
113 {
114 PrintManagerClient::GetInstance()->LoadServerFail();
115 EXPECT_EQ(PrintManagerClient::GetInstance()->ready_, false);
116
117 PrintManagerClient::GetInstance()->ResetProxy();
118 EXPECT_EQ(PrintManagerClient::GetInstance()->printServiceProxy_, nullptr);
119 }
120
121
122 /**
123 * @tc.name: PrintManagerClientTest_0004
124 * @tc.desc: StartPrint success case.
125 * @tc.type: FUNC
126 * @tc.require:
127 */
128 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0004, TestSize.Level1)
129 {
130 std::vector<std::string> testFileList = {"file://data/print/a.png",
131 "file://data/print/b.png", "file://data/print/c.png"};
132 std::vector<uint32_t> testFdList = {1, 2};
133 std::string testTaskId = "2";
134
135 auto service = std::make_shared<MockPrintService>();
136 EXPECT_NE(service, nullptr);
137 EXPECT_CALL(*service, StartPrint(_, _, _)).Times(1);
138 ON_CALL(*service, StartPrint(_, _, _)).WillByDefault(
139 [&testFileList, &testFdList, &testTaskId](const std::vector<std::string> &fileList,
__anone9e578950302(const std::vector<std::string> &fileList, const std::vector<uint32_t> &fdList, std::string &taskId) 140 const std::vector<uint32_t> &fdList, std::string &taskId) {
141 EXPECT_EQ(testFileList.size(), fileList.size());
142 for (size_t index = 0; index < testFileList.size(); index++) {
143 EXPECT_EQ(testFileList[index], fileList[index]);
144 }
145 EXPECT_EQ(testFdList.size(), fdList.size());
146 return E_PRINT_NONE;
147 });
148 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
149 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
150 CallRemoteObject(service, obj, dr);
151 PrintManagerClient::GetInstance()->LoadServerSuccess();
152 int32_t ret = PrintManagerClient::GetInstance()->StartPrint(testFileList, testFdList, testTaskId);
153 EXPECT_EQ(ret, E_PRINT_NONE);
154 EXPECT_NE(dr, nullptr);
155 dr->OnRemoteDied(obj);
156 }
157
158 /**
159 * @tc.name: PrintManagerClientTest_0005
160 * @tc.desc: StopPrint failed case.
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0005, TestSize.Level1)
165 {
166 std::string testTaskId = "2";
167
168 PrintManagerClient::GetInstance()->LoadServerFail();
169 int32_t ret = PrintManagerClient::GetInstance()->StopPrint(testTaskId);
170 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
171 }
172
173 /**
174 * @tc.name: PrintManagerClientTest_0006
175 * @tc.desc: StopPrint failed case.
176 * @tc.type: FUNC
177 * @tc.require:
178 */
179 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0006, TestSize.Level1)
180 {
181 std::string testTaskId = "2";
182
183 PrintManagerClient::GetInstance()->LoadServerSuccess();
184 PrintManagerClient::GetInstance()->ResetProxy();
185 int32_t ret = PrintManagerClient::GetInstance()->StopPrint(testTaskId);
186 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
187 }
188
189 /**
190 * @tc.name: PrintManagerClientTest_0007
191 * @tc.desc: StartPrint failed case.
192 * @tc.type: FUNC
193 * @tc.require:
194 */
195 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0007, TestSize.Level1)
196 {
197 std::string testTaskId = "2";
198
199 PrintManagerClient::GetInstance()->LoadServerFail();
200 PrintManagerClient::GetInstance()->ResetProxy();
201 int32_t ret = PrintManagerClient::GetInstance()->StopPrint(testTaskId);
202 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
203 }
204
205 /**
206 * @tc.name: PrintManagerClientTest_0008
207 * @tc.desc: StopPrint succedd case.
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0008, TestSize.Level1)
212 {
213 std::string testTaskId = "2";
214 auto service = std::make_shared<MockPrintService>();
215 EXPECT_NE(service, nullptr);
216 EXPECT_CALL(*service, StopPrint(_)).Times(1);
217 ON_CALL(*service, StopPrint).WillByDefault(
__anone9e578950402(const std::string &taskId) 218 [&testTaskId](const std::string &taskId) {
219 EXPECT_EQ(testTaskId, taskId);
220 return E_PRINT_NONE;
221 });
222 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
223 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
224 CallRemoteObject(service, obj, dr);
225 PrintManagerClient::GetInstance()->LoadServerSuccess();
226 int32_t ret = PrintManagerClient::GetInstance()->StopPrint(testTaskId);
227 EXPECT_EQ(ret, E_PRINT_NONE);
228 EXPECT_NE(dr, nullptr);
229 dr->OnRemoteDied(obj);
230 }
231
232 /**
233 * @tc.name: PrintManagerClientTest_0009
234 * @tc.desc: QueryAllExtension
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0009, TestSize.Level1)
239 {
240 std::vector<PrintExtensionInfo> extensionInfos;
241 PrintManagerClient::GetInstance()->LoadServerFail();
242 int32_t ret = PrintManagerClient::GetInstance()->QueryAllExtension(extensionInfos);
243 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
244 }
245
246 /**
247 * @tc.name: PrintManagerClientTest_00010
248 * @tc.desc: QueryAllExtension_NA1
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_00010, TestSize.Level1)
253 {
254 std::vector<PrintExtensionInfo> extensionInfos;
255 PrintManagerClient::GetInstance()->LoadServerSuccess();
256 PrintManagerClient::GetInstance()->ResetProxy();
257 int32_t ret = PrintManagerClient::GetInstance()->QueryAllExtension(extensionInfos);
258 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
259 }
260
261 /**
262 * @tc.name: PrintManagerClientTest_0011
263 * @tc.desc: StartPrint failed case.
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0011, TestSize.Level1)
268 {
269 std::vector<PrintExtensionInfo> extensionInfos;
270 PrintManagerClient::GetInstance()->LoadServerFail();
271 PrintManagerClient::GetInstance()->ResetProxy();
272 int32_t ret = PrintManagerClient::GetInstance()->QueryAllExtension(extensionInfos);
273 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
274 }
275
276
277 /**
278 * @tc.name: PrintManagerClientTest_0012
279 * @tc.desc: StartDiscoverPrinter
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0012, TestSize.Level1)
284 {
285 PrintExtensionInfo info1, info2;
286 info1.SetExtensionId("ext-123");
287 info2.SetExtensionId("ext-123");
288 std::vector<PrintExtensionInfo> testExtensionInfos = {info1, info2};
289
290 auto service = std::make_shared<MockPrintService>();
291 EXPECT_NE(service, nullptr);
292 EXPECT_CALL(*service, QueryAllExtension(_)).Times(1);
293 ON_CALL(*service, QueryAllExtension).WillByDefault(
__anone9e578950502(std::vector<PrintExtensionInfo> &extensionInfos) 294 [&testExtensionInfos](std::vector<PrintExtensionInfo> &extensionInfos) {
295 extensionInfos.assign(testExtensionInfos.begin(), testExtensionInfos.end());
296 return E_PRINT_NONE;
297 });
298 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
299 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
300 CallRemoteObject(service, obj, dr);
301 PrintManagerClient::GetInstance()->LoadServerSuccess();
302 std::vector<PrintExtensionInfo> result;
303 int32_t ret = PrintManagerClient::GetInstance()->QueryAllExtension(result);
304 EXPECT_EQ(testExtensionInfos.size(), result.size());
305 for (size_t index = 0; index < testExtensionInfos.size(); index++) {
306 EXPECT_EQ(testExtensionInfos[index].GetExtensionId(), result[index].GetExtensionId());
307 }
308 EXPECT_EQ(ret, E_PRINT_NONE);
309 EXPECT_NE(dr, nullptr);
310 dr->OnRemoteDied(obj);
311 }
312
313 /**
314 * @tc.name: PrintManagerClientTest_0013
315 * @tc.desc: QueryAllExtension
316 * @tc.type: FUNC
317 * @tc.require:
318 */
319 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0013, TestSize.Level1)
320 {
321 std::vector<std::string> testExtensionList = {"extensionId-1", "extensionId-2"};
322
323 PrintManagerClient::GetInstance()->LoadServerFail();
324 int32_t ret = PrintManagerClient::GetInstance()->StartDiscoverPrinter(testExtensionList);
325 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
326 }
327
328 /**
329 * @tc.name: PrintManagerClientTest_0014
330 * @tc.desc: QueryAllExtension_NA1
331 * @tc.type: FUNC
332 * @tc.require:
333 */
334 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0014, TestSize.Level1)
335 {
336 std::vector<std::string> testExtensionList = {"extensionId-1", "extensionId-2"};
337
338 PrintManagerClient::GetInstance()->LoadServerSuccess();
339 PrintManagerClient::GetInstance()->ResetProxy();
340 int32_t ret = PrintManagerClient::GetInstance()->StartDiscoverPrinter(testExtensionList);
341 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
342 }
343
344 /**
345 * @tc.name: PrintManagerClientTest_0015
346 * @tc.desc: StartPrint failed case.
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0015, TestSize.Level1)
351 {
352 std::vector<std::string> testExtensionList = {"extensionId-1", "extensionId-2"};
353 std::vector<PrintExtensionInfo> extensionInfos;
354 PrintManagerClient::GetInstance()->LoadServerFail();
355 PrintManagerClient::GetInstance()->ResetProxy();
356 int32_t ret = PrintManagerClient::GetInstance()->StartDiscoverPrinter(testExtensionList);
357 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
358 }
359
360 /**
361 * @tc.name: PrintManagerClientTest_0016
362 * @tc.desc: StartDiscoverPrinter
363 * @tc.type: FUNC
364 * @tc.require:
365 */
366 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0016, TestSize.Level1)
367 {
368 std::vector<std::string> testExtensionList = {"extensionId-1", "extensionId-2"};
369
370 auto service = std::make_shared<MockPrintService>();
371 EXPECT_NE(service, nullptr);
372 EXPECT_CALL(*service, StartDiscoverPrinter(_)).Times(1);
373 ON_CALL(*service, StartDiscoverPrinter).WillByDefault(
__anone9e578950602(const std::vector<std::string> &extensionList) 374 [&testExtensionList](const std::vector<std::string> &extensionList) {
375 return E_PRINT_NONE;
376 });
377 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
378 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
379 CallRemoteObject(service, obj, dr);
380 PrintManagerClient::GetInstance()->LoadServerSuccess();
381 int32_t ret = PrintManagerClient::GetInstance()->StartDiscoverPrinter(testExtensionList);
382 EXPECT_EQ(ret, E_PRINT_NONE);
383 EXPECT_NE(dr, nullptr);
384 dr->OnRemoteDied(obj);
385 }
386
387 /**
388 * @tc.name: PrintManagerClientTest_0017
389 * @tc.desc: QueryAllExtension
390 * @tc.type: FUNC
391 * @tc.require:
392 */
393 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0017, TestSize.Level1)
394 {
395 PrintManagerClient::GetInstance()->LoadServerFail();
396 int32_t ret = PrintManagerClient::GetInstance()->StopDiscoverPrinter();
397 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
398 }
399
400 /**
401 * @tc.name: PrintManagerClientTest_0018
402 * @tc.desc: QueryAllExtension_NA1
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0018, TestSize.Level1)
407 {
408 PrintManagerClient::GetInstance()->LoadServerSuccess();
409 PrintManagerClient::GetInstance()->ResetProxy();
410 int32_t ret = PrintManagerClient::GetInstance()->StopDiscoverPrinter();
411 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
412 }
413
414 /**
415 * @tc.name: PrintManagerClientTest_0019
416 * @tc.desc: StartPrint failed case.
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0019, TestSize.Level1)
421 {
422 std::vector<std::string> testExtensionList = {"extensionId-1", "extensionId-2"};
423 std::vector<PrintExtensionInfo> extensionInfos;
424 PrintManagerClient::GetInstance()->LoadServerFail();
425 PrintManagerClient::GetInstance()->ResetProxy();
426 int32_t ret = PrintManagerClient::GetInstance()->StartDiscoverPrinter(testExtensionList);
427 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
428 }
429
430 /**
431 * @tc.name: PrintManagerClientTest_0020
432 * @tc.desc: StartDiscoverPrinter
433 * @tc.type: FUNC
434 * @tc.require:
435 */
436 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0020, TestSize.Level1)
437 {
438 auto service = std::make_shared<MockPrintService>();
439 EXPECT_NE(service, nullptr);
440 EXPECT_CALL(*service, StopDiscoverPrinter()).Times(1);
441 ON_CALL(*service, StopDiscoverPrinter).WillByDefault(
__anone9e578950702() 442 []() {
443 return E_PRINT_NONE;
444 });
445 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
446 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
447 CallRemoteObject(service, obj, dr);
448 PrintManagerClient::GetInstance()->LoadServerSuccess();
449 int32_t ret = PrintManagerClient::GetInstance()->StopDiscoverPrinter();
450 EXPECT_EQ(ret, E_PRINT_NONE);
451 EXPECT_NE(dr, nullptr);
452 dr->OnRemoteDied(obj);
453 }
454
455 /**
456 * @tc.name: PrintManagerClientTest_0021
457 * @tc.desc: QueryAllExtension
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0021, TestSize.Level1)
462 {
463 std::vector<PrinterInfo> printerInfos;
464 PrintManagerClient::GetInstance()->LoadServerFail();
465 int32_t ret = PrintManagerClient::GetInstance()->AddPrinters(printerInfos);
466 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
467 }
468
469 /**
470 * @tc.name: PrintManagerClientTest_0022
471 * @tc.desc: QueryAllExtension_NA1
472 * @tc.type: FUNC
473 * @tc.require:
474 */
475 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0022, TestSize.Level1)
476 {
477 std::vector<PrinterInfo> printerInfos;
478 PrintManagerClient::GetInstance()->LoadServerSuccess();
479 PrintManagerClient::GetInstance()->ResetProxy();
480 int32_t ret = PrintManagerClient::GetInstance()->AddPrinters(printerInfos);
481 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
482 }
483
484 /**
485 * @tc.name: PrintManagerClientTest_0023
486 * @tc.desc: StartPrint failed case.
487 * @tc.type: FUNC
488 * @tc.require:
489 */
490 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0023, TestSize.Level1)
491 {
492 std::vector<PrinterInfo> printerInfos;
493 PrintManagerClient::GetInstance()->LoadServerFail();
494 PrintManagerClient::GetInstance()->ResetProxy();
495 int32_t ret = PrintManagerClient::GetInstance()->AddPrinters(printerInfos);
496 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
497 }
498
499 /**
500 * @tc.name: PrintManagerClientTest_0024
501 * @tc.desc: StartDiscoverPrinter
502 * @tc.type: FUNC
503 * @tc.require:
504 */
505 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0024, TestSize.Level1)
506 {
507 OHOS::Print::PrinterInfo printerInfo;
508 std::string printerId = "printId-123";
509 printerInfo.SetPrinterId(printerId);
510 printerInfo.SetPrinterName("1");
511 printerInfo.SetPrinterIcon(1);
512 printerInfo.SetPrinterState(1);
513 printerInfo.SetDescription("111");
514 const PrinterCapability capability;
515 printerInfo.SetCapability(capability);
516 const std::string option = "1";
517 printerInfo.SetOption(option);
518 std::vector<PrinterInfo> testPrinterInfos;
519 testPrinterInfos.emplace_back(printerInfo);
520
521 auto service = std::make_shared<MockPrintService>();
522 EXPECT_NE(service, nullptr);
523 EXPECT_CALL(*service, AddPrinters(_)).Times(1);
524 ON_CALL(*service, AddPrinters).WillByDefault(
__anone9e578950802(const std::vector<PrinterInfo> &printerInfos) 525 [&testPrinterInfos](const std::vector<PrinterInfo> &printerInfos) {
526 EXPECT_EQ(testPrinterInfos.size(), printerInfos.size());
527 for (size_t index = 0; index < testPrinterInfos.size(); index++) {
528 EXPECT_EQ(testPrinterInfos[index].GetOption(), printerInfos[index].GetOption());
529 }
530 return E_PRINT_NONE;
531 });
532 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
533 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
534 CallRemoteObject(service, obj, dr);
535 PrintManagerClient::GetInstance()->LoadServerSuccess();
536 int32_t ret = PrintManagerClient::GetInstance()->AddPrinters(testPrinterInfos);
537 EXPECT_EQ(ret, E_PRINT_NONE);
538 EXPECT_NE(dr, nullptr);
539 dr->OnRemoteDied(obj);
540 }
541
542 /**
543 * @tc.name: PrintManagerClientTest_0025
544 * @tc.desc: QueryAllExtension
545 * @tc.type: FUNC
546 * @tc.require:
547 */
548 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0025, TestSize.Level1)
549 {
550 std::vector<std::string> testPrinterIds = {"printerId-1", "printerId-2"};
551
552 PrintManagerClient::GetInstance()->LoadServerFail();
553 int32_t ret = PrintManagerClient::GetInstance()->RemovePrinters(testPrinterIds);
554 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
555 }
556
557 /**
558 * @tc.name: PrintManagerClientTest_0026
559 * @tc.desc: QueryAllExtension_NA1
560 * @tc.type: FUNC
561 * @tc.require:
562 */
563 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0026, TestSize.Level1)
564 {
565 std::vector<std::string> testPrinterIds = {"printerId-1", "printerId-2"};
566 PrintManagerClient::GetInstance()->LoadServerSuccess();
567 PrintManagerClient::GetInstance()->ResetProxy();
568 int32_t ret = PrintManagerClient::GetInstance()->RemovePrinters(testPrinterIds);
569 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
570 }
571
572 /**
573 * @tc.name: PrintManagerClientTest_0027
574 * @tc.desc: StartPrint failed case.
575 * @tc.type: FUNC
576 * @tc.require:
577 */
578 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0027, TestSize.Level1)
579 {
580 std::vector<std::string> testPrinterIds = {"printerId-1", "printerId-2"};
581 std::vector<PrinterInfo> printerInfos;
582 PrintManagerClient::GetInstance()->LoadServerFail();
583 PrintManagerClient::GetInstance()->ResetProxy();
584 int32_t ret = PrintManagerClient::GetInstance()->RemovePrinters(testPrinterIds);
585 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
586 }
587
588 /**
589 * @tc.name: PrintManagerClientTest_0028
590 * @tc.desc: RemovePrinters
591 * @tc.type: FUNC
592 * @tc.require:
593 */
594 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0028, TestSize.Level1)
595 {
596 std::vector<std::string> testPrinterIds = {"printerId-1", "printerId-2"};
597 auto service = std::make_shared<MockPrintService>();
598 EXPECT_NE(service, nullptr);
599 EXPECT_CALL(*service, RemovePrinters(_)).Times(1);
600 ON_CALL(*service, RemovePrinters).WillByDefault(
__anone9e578950902(const std::vector<std::string> &printerIds) 601 [&testPrinterIds](const std::vector<std::string> &printerIds) {
602 EXPECT_EQ(testPrinterIds.size(), printerIds.size());
603 for (size_t index = 0; index < testPrinterIds.size(); index++) {
604 EXPECT_EQ(testPrinterIds[index], testPrinterIds[index]);
605 }
606 return E_PRINT_NONE;
607 });
608 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
609 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
610 CallRemoteObject(service, obj, dr);
611 PrintManagerClient::GetInstance()->LoadServerSuccess();
612 int32_t ret = PrintManagerClient::GetInstance()->RemovePrinters(testPrinterIds);
613 EXPECT_EQ(ret, E_PRINT_NONE);
614 EXPECT_NE(dr, nullptr);
615 dr->OnRemoteDied(obj);
616 }
617
618 /**
619 * @tc.name: PrintManagerClientTest_0029
620 * @tc.desc: QueryAllExtension
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0029, TestSize.Level1)
625 {
626 std::vector<PrinterInfo> printerInfos;
627 PrintManagerClient::GetInstance()->LoadServerFail();
628 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinters(printerInfos);
629 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
630 }
631
632 /**
633 * @tc.name: PrintManagerClientTest_0030
634 * @tc.desc: QueryAllExtension_NA1
635 * @tc.type: FUNC
636 * @tc.require:
637 */
638 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0030, TestSize.Level1)
639 {
640 std::vector<PrinterInfo> printerInfos;
641 PrintManagerClient::GetInstance()->LoadServerSuccess();
642 PrintManagerClient::GetInstance()->ResetProxy();
643 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinters(printerInfos);
644 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
645 }
646
647 /**
648 * @tc.name: PrintManagerClientTest_0031
649 * @tc.desc: StartPrint failed case.
650 * @tc.type: FUNC
651 * @tc.require:
652 */
653 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0031, TestSize.Level1)
654 {
655 std::vector<PrinterInfo> printerInfos;
656 PrintManagerClient::GetInstance()->LoadServerFail();
657 PrintManagerClient::GetInstance()->ResetProxy();
658 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinters(printerInfos);
659 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
660 }
661
662 /**
663 * @tc.name: PrintManagerClientTest_0032
664 * @tc.desc: StartDiscoverPrinter
665 * @tc.type: FUNC
666 * @tc.require:
667 */
668 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0032, TestSize.Level1)
669 {
670 PrinterInfo printerInfo;
671 std::string printerId = "printId-123";
672 printerInfo.SetPrinterId(printerId);
673 printerInfo.SetPrinterName("1");
674 printerInfo.SetPrinterIcon(1);
675 printerInfo.SetPrinterState(1);
676 printerInfo.SetDescription("111");
677 const PrinterCapability capability;
678 printerInfo.SetCapability(capability);
679 const std::string option = "1";
680 printerInfo.SetOption(option);
681 std::vector<PrinterInfo> testPrinterInfos;
682 testPrinterInfos.emplace_back(printerInfo);
683
684 auto service = std::make_shared<MockPrintService>();
685 EXPECT_NE(service, nullptr);
686 EXPECT_CALL(*service, UpdatePrinters(_)).Times(1);
687 ON_CALL(*service, UpdatePrinters).WillByDefault(
__anone9e578950a02(const std::vector<PrinterInfo> &printerInfos) 688 [&testPrinterInfos](const std::vector<PrinterInfo> &printerInfos) {
689 EXPECT_EQ(testPrinterInfos.size(), printerInfos.size());
690 for (size_t index = 0; index < testPrinterInfos.size(); index++) {
691 EXPECT_EQ(testPrinterInfos[index].GetOption(), printerInfos[index].GetOption());
692 }
693 return E_PRINT_NONE;
694 });
695 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
696 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
697 CallRemoteObject(service, obj, dr);
698 PrintManagerClient::GetInstance()->LoadServerSuccess();
699 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinters(testPrinterInfos);
700 EXPECT_EQ(ret, E_PRINT_NONE);
701 EXPECT_NE(dr, nullptr);
702 dr->OnRemoteDied(obj);
703 }
704
705 /**
706 * @tc.name: PrintManagerClientTest_0033
707 * @tc.desc: ConnectPrinter
708 * @tc.type: FUNC
709 * @tc.require:
710 */
711 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0033, TestSize.Level1)
712 {
713 std::string printerId = "printerId-1";
714 PrintManagerClient::GetInstance()->LoadServerFail();
715 int32_t ret = PrintManagerClient::GetInstance()->ConnectPrinter(printerId);
716 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
717 }
718
719 /**
720 * @tc.name: PrintManagerClientTest_0034
721 * @tc.desc: ConnectPrinter
722 * @tc.type: FUNC
723 * @tc.require:
724 */
725 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0034, TestSize.Level1)
726 {
727 std::string printerId = "printerId-1";
728 PrintManagerClient::GetInstance()->LoadServerSuccess();
729 PrintManagerClient::GetInstance()->ResetProxy();
730 int32_t ret = PrintManagerClient::GetInstance()->ConnectPrinter(printerId);
731 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
732 }
733
734 /**
735 * @tc.name: PrintManagerClientTest_0035
736 * @tc.desc: StartPrint failed case.
737 * @tc.type: FUNC
738 * @tc.require:
739 */
740 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0035, TestSize.Level1)
741 {
742 std::string printerId = "printerId-1";
743 PrintManagerClient::GetInstance()->LoadServerFail();
744 PrintManagerClient::GetInstance()->ResetProxy();
745 int32_t ret = PrintManagerClient::GetInstance()->ConnectPrinter(printerId);
746 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
747 }
748
749 /**
750 * @tc.name: PrintManagerClientTest_0036
751 * @tc.desc: ConnectPrinter
752 * @tc.type: FUNC
753 * @tc.require:
754 */
755 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0036, TestSize.Level1)
756 {
757 std::string testPrinterId = "printerId-1";
758
759 auto service = std::make_shared<MockPrintService>();
760 EXPECT_NE(service, nullptr);
761 EXPECT_CALL(*service, ConnectPrinter(_)).Times(1);
762 ON_CALL(*service, ConnectPrinter).WillByDefault(
__anone9e578950b02(const std::string &printerId) 763 [&testPrinterId](const std::string &printerId) {
764 EXPECT_EQ(testPrinterId, printerId);
765 return E_PRINT_NONE;
766 });
767 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
768 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
769 CallRemoteObject(service, obj, dr);
770 PrintManagerClient::GetInstance()->LoadServerSuccess();
771 int32_t ret = PrintManagerClient::GetInstance()->ConnectPrinter(testPrinterId);
772 EXPECT_EQ(ret, E_PRINT_NONE);
773 EXPECT_NE(dr, nullptr);
774 dr->OnRemoteDied(obj);
775 }
776
777 /**
778 * @tc.name: PrintManagerClientTest_0037
779 * @tc.desc: DisconnectPrinter
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0037, TestSize.Level1)
784 {
785 std::string printerId = "printerId-1";
786
787 PrintManagerClient::GetInstance()->LoadServerFail();
788 int32_t ret = PrintManagerClient::GetInstance()->DisconnectPrinter(printerId);
789 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
790 }
791
792 /**
793 * @tc.name: PrintManagerClientTest_0038
794 * @tc.desc: DisconnectPrinter
795 * @tc.type: FUNC
796 * @tc.require:
797 */
798 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0038, TestSize.Level1)
799 {
800 std::string printerId = "printerId-1";
801
802 PrintManagerClient::GetInstance()->LoadServerSuccess();
803 PrintManagerClient::GetInstance()->ResetProxy();
804 int32_t ret = PrintManagerClient::GetInstance()->DisconnectPrinter(printerId);
805 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
806 }
807
808 /**
809 * @tc.name: PrintManagerClientTest_0039
810 * @tc.desc: StartPrint failed case.
811 * @tc.type: FUNC
812 * @tc.require:
813 */
814 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0039, TestSize.Level1)
815 {
816 std::string printerId = "printerId-1";
817 PrintManagerClient::GetInstance()->LoadServerFail();
818 PrintManagerClient::GetInstance()->ResetProxy();
819 int32_t ret = PrintManagerClient::GetInstance()->DisconnectPrinter(printerId);
820 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
821 }
822
823
824 /**
825 * @tc.name: PrintManagerClientTest_0040
826 * @tc.desc: DisconnectPrinter
827 * @tc.type: FUNC
828 * @tc.require:
829 */
830 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0040, TestSize.Level1)
831 {
832 std::string testPrinterId = "printerId-1";
833
834 auto service = std::make_shared<MockPrintService>();
835 EXPECT_NE(service, nullptr);
836 EXPECT_CALL(*service, DisconnectPrinter(_)).Times(1);
837 ON_CALL(*service, DisconnectPrinter).WillByDefault(
__anone9e578950c02(const std::string &printerId) 838 [&testPrinterId](const std::string &printerId) {
839 EXPECT_EQ(testPrinterId, printerId);
840 return E_PRINT_NONE;
841 });
842 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
843 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
844 CallRemoteObject(service, obj, dr);
845 PrintManagerClient::GetInstance()->LoadServerSuccess();
846 int32_t ret = PrintManagerClient::GetInstance()->DisconnectPrinter(testPrinterId);
847 EXPECT_EQ(ret, E_PRINT_NONE);
848 EXPECT_NE(dr, nullptr);
849 dr->OnRemoteDied(obj);
850 }
851
852 /**
853 * @tc.name: PrintManagerClientTest_0041
854 * @tc.desc: StartPrintJob
855 * @tc.type: FUNC
856 * @tc.require:
857 */
858 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0041, TestSize.Level1)
859 {
860 PrintJob jobinfo;
861 PrintManagerClient::GetInstance()->LoadServerFail();
862 int32_t ret = PrintManagerClient::GetInstance()->StartPrintJob(jobinfo);
863 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
864 }
865
866 /**
867 * @tc.name: PrintManagerClientTest_0042
868 * @tc.desc: StartPrintJob
869 * @tc.type: FUNC
870 * @tc.require:
871 */
872 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0042, TestSize.Level1)
873 {
874 PrintJob jobinfo;
875
876 PrintManagerClient::GetInstance()->LoadServerSuccess();
877 PrintManagerClient::GetInstance()->ResetProxy();
878 int32_t ret = PrintManagerClient::GetInstance()->StartPrintJob(jobinfo);
879 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
880 }
881
882 /**
883 * @tc.name: PrintManagerClientTest_0043
884 * @tc.desc: StartPrint failed case.
885 * @tc.type: FUNC
886 * @tc.require:
887 */
888 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0043, TestSize.Level1)
889 {
890 PrintJob jobinfo;
891 PrintManagerClient::GetInstance()->LoadServerFail();
892 PrintManagerClient::GetInstance()->ResetProxy();
893 int32_t ret = PrintManagerClient::GetInstance()->StartPrintJob(jobinfo);
894 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
895 }
896
897 /**
898 * @tc.name: PrintManagerClientTest_0044
899 * @tc.desc: StartPrintJob
900 * @tc.type: FUNC
901 * @tc.require:
902 */
903 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0044, TestSize.Level1)
904 {
905 OHOS::Print::PrintJob testJob;
906 testJob.SetJobId("jobId-123");
907 auto service = std::make_shared<MockPrintService>();
908 EXPECT_NE(service, nullptr);
909 EXPECT_CALL(*service, StartPrintJob(_)).Times(1);
910 ON_CALL(*service, StartPrintJob).WillByDefault(
__anone9e578950d02(const PrintJob &jobinfo) 911 [&testJob](const PrintJob &jobinfo) {
912 EXPECT_EQ(testJob.GetJobId(), jobinfo.GetJobId());
913 return E_PRINT_NONE;
914 });
915 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
916 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
917 CallRemoteObject(service, obj, dr);
918 PrintManagerClient::GetInstance()->LoadServerSuccess();
919 int32_t ret = PrintManagerClient::GetInstance()->StartPrintJob(testJob);
920 EXPECT_EQ(ret, E_PRINT_NONE);
921 EXPECT_NE(dr, nullptr);
922 dr->OnRemoteDied(obj);
923 }
924
925 /**
926 * @tc.name: PrintManagerClientTest_0045
927 * @tc.desc: CancelPrintJob
928 * @tc.type: FUNC
929 * @tc.require:
930 */
931 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0045, TestSize.Level1)
932 {
933 std::string jobId = "jobId-1";
934
935 PrintManagerClient::GetInstance()->LoadServerFail();
936 int32_t ret = PrintManagerClient::GetInstance()->CancelPrintJob(jobId);
937 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
938 }
939
940 /**
941 * @tc.name: PrintManagerClientTest_0046
942 * @tc.desc: CancelPrintJob
943 * @tc.type: FUNC
944 * @tc.require:
945 */
946 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0046, TestSize.Level1)
947 {
948 std::string jobId = "jobId-1";
949
950 PrintManagerClient::GetInstance()->LoadServerSuccess();
951 PrintManagerClient::GetInstance()->ResetProxy();
952 int32_t ret = PrintManagerClient::GetInstance()->CancelPrintJob(jobId);
953 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
954 }
955
956 /**
957 * @tc.name: PrintManagerClientTest_0047
958 * @tc.desc: StartPrint failed case.
959 * @tc.type: FUNC
960 * @tc.require:
961 */
962 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0047, TestSize.Level1)
963 {
964 std::string jobId = "jobId-1";
965 PrintManagerClient::GetInstance()->LoadServerFail();
966 PrintManagerClient::GetInstance()->ResetProxy();
967 int32_t ret = PrintManagerClient::GetInstance()->CancelPrintJob(jobId);
968 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
969 }
970
971 /**
972 * @tc.name: PrintManagerClientTest_0048
973 * @tc.desc: CancelPrintJob
974 * @tc.type: FUNC
975 * @tc.require:
976 */
977 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0048, TestSize.Level1)
978 {
979 std::string testJobId = "jobId-1";
980
981 auto service = std::make_shared<MockPrintService>();
982 EXPECT_NE(service, nullptr);
983 EXPECT_CALL(*service, CancelPrintJob(_)).Times(1);
984 ON_CALL(*service, CancelPrintJob).WillByDefault(
__anone9e578950e02(const std::string &jobId) 985 [&testJobId](const std::string &jobId) {
986 EXPECT_EQ(testJobId, jobId);
987 return E_PRINT_NONE;
988 });
989 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
990 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
991 CallRemoteObject(service, obj, dr);
992 PrintManagerClient::GetInstance()->LoadServerSuccess();
993 int32_t ret = PrintManagerClient::GetInstance()->CancelPrintJob(testJobId);
994 EXPECT_EQ(ret, E_PRINT_NONE);
995 EXPECT_NE(dr, nullptr);
996 dr->OnRemoteDied(obj);
997 }
998
999 /**
1000 * @tc.name: PrintManagerClientTest_0049
1001 * @tc.desc: UpdatePrinterState
1002 * @tc.type: FUNC
1003 * @tc.require:
1004 */
1005 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0049, TestSize.Level1)
1006 {
1007 std::string printerId = "printerId-1";
1008 uint32_t state = 6;
1009
1010 PrintManagerClient::GetInstance()->LoadServerFail();
1011 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinterState(printerId, state);
1012 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1013 }
1014
1015 /**
1016 * @tc.name: PrintManagerClientTest_0050
1017 * @tc.desc: UpdatePrinterState
1018 * @tc.type: FUNC
1019 * @tc.require:
1020 */
1021 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0050, TestSize.Level1)
1022 {
1023 std::string printerId = "printerId-1";
1024 uint32_t state = 6;
1025
1026 PrintManagerClient::GetInstance()->LoadServerSuccess();
1027 PrintManagerClient::GetInstance()->ResetProxy();
1028 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinterState(printerId, state);
1029 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1030 }
1031
1032 /**
1033 * @tc.name: PrintManagerClientTest_0051
1034 * @tc.desc: StartPrint failed case.
1035 * @tc.type: FUNC
1036 * @tc.require:
1037 */
1038 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0051, TestSize.Level1)
1039 {
1040 std::string printerId = "printerId-1";
1041 uint32_t state = 6;
1042 PrintManagerClient::GetInstance()->LoadServerFail();
1043 PrintManagerClient::GetInstance()->ResetProxy();
1044 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinterState(printerId, state);
1045 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1046 }
1047
1048 /**
1049 * @tc.name: PrintManagerClientTest_0052
1050 * @tc.desc: UpdatePrinterState
1051 * @tc.type: FUNC
1052 * @tc.require:
1053 */
1054 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0052, TestSize.Level1)
1055 {
1056 std::string testPrinterId = "printerId-1";
1057 uint32_t testState = 6;
1058 auto service = std::make_shared<MockPrintService>();
1059 EXPECT_NE(service, nullptr);
1060 EXPECT_CALL(*service, UpdatePrinterState(_, _)).Times(1);
1061 ON_CALL(*service, UpdatePrinterState).WillByDefault(
__anone9e578950f02(const std::string &printerId, const uint32_t &state) 1062 [&testPrinterId, &testState](const std::string &printerId, const uint32_t &state) {
1063 EXPECT_EQ(testPrinterId, printerId);
1064 EXPECT_EQ(testState, state);
1065 return E_PRINT_NONE;
1066 });
1067 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1068 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1069 CallRemoteObject(service, obj, dr);
1070 PrintManagerClient::GetInstance()->LoadServerSuccess();
1071 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinterState(testPrinterId, testState);
1072 EXPECT_EQ(ret, E_PRINT_NONE);
1073 EXPECT_NE(dr, nullptr);
1074 dr->OnRemoteDied(obj);
1075 }
1076
1077 /**
1078 * @tc.name: PrintManagerClientTest_0053
1079 * @tc.desc: UpdatePrintJobStateOnlyForSystemApp
1080 * @tc.type: FUNC
1081 * @tc.require:
1082 */
1083 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0053, TestSize.Level1)
1084 {
1085 std::string printerId = "printerId-1";
1086 uint32_t state = 6;
1087 uint32_t subState = 6;
1088 PrintManagerClient::GetInstance()->LoadServerFail();
1089 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrintJobStateOnlyForSystemApp(printerId, state, subState);
1090 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1091 }
1092
1093 /**
1094 * @tc.name: PrintManagerClientTest_0054
1095 * @tc.desc: UpdatePrintJobStateOnlyForSystemApp
1096 * @tc.type: FUNC
1097 * @tc.require:
1098 */
1099 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0054, TestSize.Level1)
1100 {
1101 std::string printerId = "printerId-1";
1102 uint32_t state = 6;
1103 uint32_t subState = 6;
1104 PrintManagerClient::GetInstance()->LoadServerSuccess();
1105 PrintManagerClient::GetInstance()->ResetProxy();
1106 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrintJobStateOnlyForSystemApp(printerId, state, subState);
1107 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1108 }
1109
1110 /**
1111 * @tc.name: PrintManagerClientTest_0055
1112 * @tc.desc: StartPrint failed case.
1113 * @tc.type: FUNC
1114 * @tc.require:
1115 */
1116 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0055, TestSize.Level1)
1117 {
1118 std::string printerId = "printerId-1";
1119 uint32_t state = 6;
1120 uint32_t subState = 6;
1121 PrintManagerClient::GetInstance()->LoadServerFail();
1122 PrintManagerClient::GetInstance()->ResetProxy();
1123 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrintJobStateOnlyForSystemApp(printerId, state, subState);
1124 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1125 }
1126
1127 /**
1128 * @tc.name: PrintManagerClientTest_0056
1129 * @tc.desc: UpdatePrintJobStateOnlyForSystemApp
1130 * @tc.type: FUNC
1131 * @tc.require:
1132 */
1133 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0056, TestSize.Level1)
1134 {
1135 std::string testPrinterId = "printerId-1";
1136 uint32_t testState = 6;
1137 uint32_t testSubState = 6;
1138 auto service = std::make_shared<MockPrintService>();
1139 EXPECT_NE(service, nullptr);
1140 EXPECT_CALL(*service, UpdatePrintJobStateOnlyForSystemApp(_, _, _)).Times(1);
1141 ON_CALL(*service, UpdatePrintJobStateOnlyForSystemApp).WillByDefault(
1142 [&testPrinterId, &testState, &testSubState](const std::string &printerId, const uint32_t &state,
__anone9e578951002(const std::string &printerId, const uint32_t &state, const uint32_t &subState) 1143 const uint32_t &subState) {
1144 EXPECT_EQ(testPrinterId, printerId);
1145 EXPECT_EQ(testState, state);
1146 EXPECT_EQ(testSubState, subState);
1147 return E_PRINT_NONE;
1148 });
1149 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1150 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1151 CallRemoteObject(service, obj, dr);
1152 PrintManagerClient::GetInstance()->LoadServerSuccess();
1153 int32_t ret =
1154 PrintManagerClient::GetInstance()->UpdatePrintJobStateOnlyForSystemApp(testPrinterId, testState, testSubState);
1155 EXPECT_EQ(ret, E_PRINT_NONE);
1156 EXPECT_NE(dr, nullptr);
1157 dr->OnRemoteDied(obj);
1158 }
1159
1160 /**
1161 * @tc.name: PrintManagerClientTest_0057
1162 * @tc.desc: UpdateExtensionInfo
1163 * @tc.type: FUNC
1164 * @tc.require:
1165 */
1166 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0057, TestSize.Level1)
1167 {
1168 std::string extensionId = "extensionId-1";
1169 PrintManagerClient::GetInstance()->LoadServerFail();
1170 int32_t ret = PrintManagerClient::GetInstance()->UpdateExtensionInfo(extensionId);
1171 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1172 }
1173
1174 /**
1175 * @tc.name: PrintManagerClientTest_0058
1176 * @tc.desc: UpdateExtensionInfo
1177 * @tc.type: FUNC
1178 * @tc.require:
1179 */
1180 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0058, TestSize.Level1)
1181 {
1182 std::string extensionId = "extensionId-1";
1183 PrintManagerClient::GetInstance()->LoadServerSuccess();
1184 PrintManagerClient::GetInstance()->ResetProxy();
1185 int32_t ret = PrintManagerClient::GetInstance()->UpdateExtensionInfo(extensionId);
1186 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1187 }
1188
1189 /**
1190 * @tc.name: PrintManagerClientTest_0059
1191 * @tc.desc: StartPrint failed case.
1192 * @tc.type: FUNC
1193 * @tc.require:
1194 */
1195 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0059, TestSize.Level1)
1196 {
1197 std::string extensionId = "extensionId-1";
1198 PrintManagerClient::GetInstance()->LoadServerFail();
1199 PrintManagerClient::GetInstance()->ResetProxy();
1200 int32_t ret = PrintManagerClient::GetInstance()->UpdateExtensionInfo(extensionId);
1201 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1202 }
1203
1204 /**
1205 * @tc.name: PrintManagerClientTest_0060
1206 * @tc.desc: UpdateExtensionInfo
1207 * @tc.type: FUNC
1208 * @tc.require:
1209 */
1210 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0060, TestSize.Level1)
1211 {
1212 std::string testExtensionId = "extensionId-1";
1213
1214 auto service = std::make_shared<MockPrintService>();
1215 EXPECT_NE(service, nullptr);
1216 EXPECT_CALL(*service, UpdateExtensionInfo(_)).Times(1);
1217 ON_CALL(*service, UpdateExtensionInfo).WillByDefault(
__anone9e578951102(const std::string &extensionId) 1218 [&testExtensionId](const std::string &extensionId) {
1219 EXPECT_EQ(testExtensionId, extensionId);
1220 return E_PRINT_NONE;
1221 });
1222 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1223 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1224 CallRemoteObject(service, obj, dr);
1225 PrintManagerClient::GetInstance()->LoadServerSuccess();
1226 int32_t ret = PrintManagerClient::GetInstance()->UpdateExtensionInfo(testExtensionId);
1227 EXPECT_EQ(ret, E_PRINT_NONE);
1228 EXPECT_NE(dr, nullptr);
1229 dr->OnRemoteDied(obj);
1230 }
1231
1232 /**
1233 * @tc.name: PrintManagerClientTest_0061
1234 * @tc.desc: RequestPreview
1235 * @tc.type: FUNC
1236 * @tc.require:
1237 */
1238 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0061, TestSize.Level1)
1239 {
1240 PrintJob jobinfo;
1241 std::string previewFilePath = "/data/temp/preview.png";
1242 PrintManagerClient::GetInstance()->LoadServerFail();
1243 int32_t ret = PrintManagerClient::GetInstance()->RequestPreview(jobinfo, previewFilePath);
1244 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1245 }
1246
1247 /**
1248 * @tc.name: PrintManagerClientTest_0062
1249 * @tc.desc: RequestPreview
1250 * @tc.type: FUNC
1251 * @tc.require:
1252 */
1253 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0062, TestSize.Level1)
1254 {
1255 PrintJob jobinfo;
1256 std::string previewFilePath = "/data/temp/preview.png";
1257 PrintManagerClient::GetInstance()->LoadServerSuccess();
1258 PrintManagerClient::GetInstance()->ResetProxy();
1259 int32_t ret = PrintManagerClient::GetInstance()->RequestPreview(jobinfo, previewFilePath);
1260 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1261 }
1262
1263 /**
1264 * @tc.name: PrintManagerClientTest_0063
1265 * @tc.desc: StartPrint failed case.
1266 * @tc.type: FUNC
1267 * @tc.require:
1268 */
1269 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0063, TestSize.Level1)
1270 {
1271 PrintJob jobinfo;
1272 std::string previewFilePath = "/data/temp/preview.png";
1273 PrintManagerClient::GetInstance()->LoadServerFail();
1274 PrintManagerClient::GetInstance()->ResetProxy();
1275 int32_t ret = PrintManagerClient::GetInstance()->RequestPreview(jobinfo, previewFilePath);
1276 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1277 }
1278
1279 /**
1280 * @tc.name: PrintManagerClientTest_0064
1281 * @tc.desc: RequestPreview
1282 * @tc.type: FUNC
1283 * @tc.require:
1284 */
1285 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0064, TestSize.Level1)
1286 {
1287 PrintJob testJobinfo;
1288 testJobinfo.SetJobId("jobId-123");
1289 std::string testPreviewFilePath = "/data/temp/preview.png";
1290 auto service = std::make_shared<MockPrintService>();
1291 EXPECT_NE(service, nullptr);
1292 EXPECT_CALL(*service, RequestPreview(_, _)).Times(1);
1293 ON_CALL(*service, RequestPreview).WillByDefault(
__anone9e578951202(const PrintJob &jobinfo, std::string &previewResult) 1294 [&testJobinfo, &testPreviewFilePath](const PrintJob &jobinfo, std::string &previewResult) {
1295 EXPECT_EQ(testJobinfo.GetJobId(), jobinfo.GetJobId());
1296 previewResult = testPreviewFilePath;
1297 return E_PRINT_NONE;
1298 });
1299 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1300 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1301 CallRemoteObject(service, obj, dr);
1302 PrintManagerClient::GetInstance()->LoadServerSuccess();
1303 std::string result;
1304 int32_t ret = PrintManagerClient::GetInstance()->RequestPreview(testJobinfo, result);
1305 EXPECT_EQ(testPreviewFilePath, result);
1306 EXPECT_EQ(ret, E_PRINT_NONE);
1307 EXPECT_NE(dr, nullptr);
1308 dr->OnRemoteDied(obj);
1309 }
1310
1311 /**
1312 * @tc.name: PrintManagerClientTest_0065
1313 * @tc.desc: QueryAllExtension
1314 * @tc.type: FUNC
1315 * @tc.require:
1316 */
1317 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0065, TestSize.Level1)
1318 {
1319 std::string testPrintId = "printId-123";
1320
1321 PrintManagerClient::GetInstance()->LoadServerFail();
1322 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapability(testPrintId);
1323 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1324 }
1325
1326 /**
1327 * @tc.name: PrintManagerClientTest_0066
1328 * @tc.desc: QueryAllExtension_NA1
1329 * @tc.type: FUNC
1330 * @tc.require:
1331 */
1332 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0066, TestSize.Level1)
1333 {
1334 std::string testPrintId = "printId-123";
1335
1336 PrintManagerClient::GetInstance()->LoadServerSuccess();
1337 PrintManagerClient::GetInstance()->ResetProxy();
1338 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapability(testPrintId);
1339 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1340 }
1341
1342 /**
1343 * @tc.name: PrintManagerClientTest_0067
1344 * @tc.desc: StartPrint failed case.
1345 * @tc.type: FUNC
1346 * @tc.require:
1347 */
1348 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0067, TestSize.Level1)
1349 {
1350 std::string testPrintId = "printId-123";
1351 PrintManagerClient::GetInstance()->LoadServerFail();
1352 PrintManagerClient::GetInstance()->ResetProxy();
1353 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapability(testPrintId);
1354 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1355 }
1356
1357 /**
1358 * @tc.name: PrintManagerClientTest_0068
1359 * @tc.desc: StartDiscoverPrinter
1360 * @tc.type: FUNC
1361 * @tc.require:
1362 */
1363 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0068, TestSize.Level1)
1364 {
1365 std::string testPrintId = "printId-123";
1366
1367 auto service = std::make_shared<MockPrintService>();
1368 EXPECT_NE(service, nullptr);
1369 EXPECT_CALL(*service, QueryPrinterCapability(_)).Times(1);
1370 ON_CALL(*service, QueryPrinterCapability).WillByDefault(
__anone9e578951302(const std::string &printerId) 1371 [&testPrintId](const std::string &printerId) {
1372 EXPECT_EQ(testPrintId, printerId);
1373 return E_PRINT_NONE;
1374 });
1375 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1376 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1377 CallRemoteObject(service, obj, dr);
1378 PrintManagerClient::GetInstance()->LoadServerSuccess();
1379 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapability(testPrintId);
1380 EXPECT_EQ(ret, E_PRINT_NONE);
1381 EXPECT_NE(dr, nullptr);
1382 dr->OnRemoteDied(obj);
1383 }
1384
1385 /**
1386 * @tc.name: PrintManagerClientTest_0069
1387 * @tc.desc: QueryAllExtension
1388 * @tc.type: FUNC
1389 * @tc.require:
1390 */
1391 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0069, TestSize.Level1)
1392 {
1393 std::vector<PrintJob> testPrintJobs;
1394
1395 PrintManagerClient::GetInstance()->LoadServerFail();
1396 int32_t ret = PrintManagerClient::GetInstance()->QueryAllPrintJob(testPrintJobs);
1397 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1398 }
1399
1400 /**
1401 * @tc.name: PrintManagerClientTest_0070
1402 * @tc.desc: QueryAllExtension_NA1
1403 * @tc.type: FUNC
1404 * @tc.require:
1405 */
1406 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0070, TestSize.Level1)
1407 {
1408 std::vector<PrintJob> testPrintJobs;
1409
1410 PrintManagerClient::GetInstance()->LoadServerSuccess();
1411 PrintManagerClient::GetInstance()->ResetProxy();
1412 int32_t ret = PrintManagerClient::GetInstance()->QueryAllPrintJob(testPrintJobs);
1413 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1414 }
1415
1416 /**
1417 * @tc.name: PrintManagerClientTest_0071
1418 * @tc.desc: StartPrint failed case.
1419 * @tc.type: FUNC
1420 * @tc.require:
1421 */
1422 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0071, TestSize.Level1)
1423 {
1424 std::vector<PrintJob> testPrintJobs;
1425 PrintManagerClient::GetInstance()->LoadServerFail();
1426 PrintManagerClient::GetInstance()->ResetProxy();
1427 int32_t ret = PrintManagerClient::GetInstance()->QueryAllPrintJob(testPrintJobs);
1428 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1429 }
1430
1431 /**
1432 * @tc.name: PrintManagerClientTest_0072
1433 * @tc.desc: StartDiscoverPrinter
1434 * @tc.type: FUNC
1435 * @tc.require:
1436 */
1437 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0072, TestSize.Level1)
1438 {
1439 PrintJob job1, job2;
1440 job1.SetJobId("1");
1441 job2.SetJobId("2");
1442 std::vector<PrintJob> testPrintJobs = {job1, job2};
1443
1444 auto service = std::make_shared<MockPrintService>();
1445 EXPECT_NE(service, nullptr);
1446 EXPECT_CALL(*service, QueryAllPrintJob(_)).Times(1);
1447 ON_CALL(*service, QueryAllPrintJob).WillByDefault(
__anone9e578951402(std::vector<PrintJob> &printJobs) 1448 [&testPrintJobs](std::vector<PrintJob> &printJobs) {
1449 printJobs.assign(testPrintJobs.begin(), testPrintJobs.end());
1450 return E_PRINT_NONE;
1451 });
1452 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1453 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1454 CallRemoteObject(service, obj, dr);
1455 PrintManagerClient::GetInstance()->LoadServerSuccess();
1456 std::vector<PrintJob> result;
1457 int32_t ret = PrintManagerClient::GetInstance()->QueryAllPrintJob(result);
1458 EXPECT_EQ(testPrintJobs.size(), result.size());
1459 for (size_t index = 0; index < testPrintJobs.size(); index++)
1460 {
1461 EXPECT_EQ(testPrintJobs[index].GetJobId(), result[index].GetJobId());
1462 }
1463 EXPECT_EQ(ret, E_PRINT_NONE);
1464 EXPECT_NE(dr, nullptr);
1465 dr->OnRemoteDied(obj);
1466 }
1467
1468 /**
1469 * @tc.name: PrintManagerClientTest_0073
1470 * @tc.desc: QueryAllExtension
1471 * @tc.type: FUNC
1472 * @tc.require:
1473 */
1474 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0073, TestSize.Level1)
1475 {
1476 std::string testPrintJobId = "jobId-123";
1477 PrintJob testPrintJob;
1478 PrintManagerClient::GetInstance()->LoadServerFail();
1479 int32_t ret = PrintManagerClient::GetInstance()->QueryPrintJobById(testPrintJobId, testPrintJob);
1480 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1481 }
1482
1483 /**
1484 * @tc.name: PrintManagerClientTest_0074
1485 * @tc.desc: QueryAllExtension_NA1
1486 * @tc.type: FUNC
1487 * @tc.require:
1488 */
1489 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0074, TestSize.Level1)
1490 {
1491 std::string testPrintJobId = "jobId-123";
1492 PrintJob testPrintJob;
1493 PrintManagerClient::GetInstance()->LoadServerSuccess();
1494 PrintManagerClient::GetInstance()->ResetProxy();
1495 int32_t ret = PrintManagerClient::GetInstance()->QueryPrintJobById(testPrintJobId, testPrintJob);
1496 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1497 }
1498
1499 /**
1500 * @tc.name: PrintManagerClientTest_0075
1501 * @tc.desc: StartPrint failed case.
1502 * @tc.type: FUNC
1503 * @tc.require:
1504 */
1505 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0075, TestSize.Level1)
1506 {
1507 std::string testPrintJobId = "jobId-123";
1508 PrintJob testPrintJob;
1509 PrintManagerClient::GetInstance()->LoadServerFail();
1510 PrintManagerClient::GetInstance()->ResetProxy();
1511 int32_t ret = PrintManagerClient::GetInstance()->QueryPrintJobById(testPrintJobId, testPrintJob);
1512 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1513 }
1514
1515 /**
1516 * @tc.name: PrintManagerClientTest_0076
1517 * @tc.desc: StartDiscoverPrinter
1518 * @tc.type: FUNC
1519 * @tc.require:
1520 */
1521 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0076, TestSize.Level1)
1522 {
1523 std::string testPrintJobId = "jobId-123";
1524 PrintJob testPrintJob;
1525 testPrintJob.SetJobId("jobId-123");
1526
1527 auto service = std::make_shared<MockPrintService>();
1528 EXPECT_NE(service, nullptr);
1529 EXPECT_CALL(*service, QueryPrintJobById(_, _)).Times(1);
1530 ON_CALL(*service, QueryPrintJobById).WillByDefault(
__anone9e578951502(std::string &printJobId, PrintJob &printJob) 1531 [&testPrintJobId, &testPrintJob](std::string &printJobId, PrintJob &printJob) {
1532 EXPECT_EQ(testPrintJobId, printJobId);
1533 printJob = testPrintJob;
1534 return E_PRINT_NONE;
1535 });
1536 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1537 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1538 CallRemoteObject(service, obj, dr);
1539 PrintManagerClient::GetInstance()->LoadServerSuccess();
1540 PrintJob result;
1541 int32_t ret = PrintManagerClient::GetInstance()->QueryPrintJobById(testPrintJobId, result);
1542 EXPECT_EQ(testPrintJob.GetJobId(), result.GetJobId());
1543 EXPECT_EQ(ret, E_PRINT_NONE);
1544 EXPECT_NE(dr, nullptr);
1545 dr->OnRemoteDied(obj);
1546 }
1547
1548 /**
1549 * @tc.name: PrintManagerClientTest_0077
1550 * @tc.desc: QueryAllExtension
1551 * @tc.type: FUNC
1552 * @tc.require:
1553 */
1554 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0077, TestSize.Level1)
1555 {
1556 std::string testTaskId = "taskId-123";
1557 std::string testType = "type";
1558 sptr<IPrintCallback> testListener;
1559
1560 PrintManagerClient::GetInstance()->LoadServerFail();
1561 int32_t ret = PrintManagerClient::GetInstance()->On(testTaskId, testType, testListener);
1562 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
1563 }
1564
1565 /**
1566 * @tc.name: PrintManagerClientTest_0078
1567 * @tc.desc: QueryAllExtension_NA1
1568 * @tc.type: FUNC
1569 * @tc.require:
1570 */
1571 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0078, TestSize.Level1)
1572 {
1573 std::string testTaskId = "taskId-123";
1574 std::string testType = "type";
1575 sptr<IPrintCallback> testListener;
1576
1577 PrintManagerClient::GetInstance()->LoadServerSuccess();
1578 PrintManagerClient::GetInstance()->ResetProxy();
1579 int32_t ret = PrintManagerClient::GetInstance()->On(testTaskId, testType, testListener);
1580 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
1581 }
1582
1583 /**
1584 * @tc.name: PrintManagerClientTest_0079
1585 * @tc.desc: StartPrint failed case.
1586 * @tc.type: FUNC
1587 * @tc.require:
1588 */
1589 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0079, TestSize.Level1)
1590 {
1591 std::string testTaskId = "taskId-123";
1592 std::string testType = "type";
1593 sptr<IPrintCallback> testListener;
1594 PrintManagerClient::GetInstance()->LoadServerFail();
1595 PrintManagerClient::GetInstance()->ResetProxy();
1596 int32_t ret = PrintManagerClient::GetInstance()->On(testTaskId, testType, testListener);
1597 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
1598 }
1599
1600 /**
1601 * @tc.name: PrintManagerClientTest_0080
1602 * @tc.desc: StartDiscoverPrinter
1603 * @tc.type: FUNC
1604 * @tc.require:
1605 */
1606 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0080, TestSize.Level1)
1607 {
1608 std::string testTaskId = "taskId-123";
1609 std::string testType = "type";
1610 sptr<IPrintCallback> testListener = new (std::nothrow) DummyPrintCallbackStub();
1611
1612 auto service = std::make_shared<MockPrintService>();
1613 EXPECT_NE(service, nullptr);
1614 EXPECT_CALL(*service, On(_, _, _)).Times(1);
1615 ON_CALL(*service, On).WillByDefault(
1616 [&testTaskId, &testType, &testListener](const std::string taskId, const std::string &type,
__anone9e578951602(const std::string taskId, const std::string &type, const sptr<IPrintCallback> &listener) 1617 const sptr<IPrintCallback> &listener) {
1618 EXPECT_EQ(testTaskId, taskId);
1619 EXPECT_EQ(testType, type);
1620 EXPECT_TRUE(testListener == listener);
1621 return E_PRINT_NONE;
1622 });
1623 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1624 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1625 CallRemoteObject(service, obj, dr);
1626 PrintManagerClient::GetInstance()->LoadServerSuccess();
1627 int32_t ret = PrintManagerClient::GetInstance()->On(testTaskId, testType, testListener);
1628 EXPECT_EQ(ret, E_PRINT_NONE);
1629 EXPECT_NE(dr, nullptr);
1630 dr->OnRemoteDied(obj);
1631 }
1632
1633 /**
1634 * @tc.name: PrintManagerClientTest_0081
1635 * @tc.desc: Off failed
1636 * @tc.type: FUNC
1637 * @tc.require:
1638 */
1639 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0081, TestSize.Level1)
1640 {
1641 std::string testTaskId = "taskId-123";
1642 std::string testType = "type";
1643
1644 PrintManagerClient::GetInstance()->LoadServerFail();
1645 int32_t ret = PrintManagerClient::GetInstance()->Off(testTaskId, testType);
1646 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1647 }
1648
1649 /**
1650 * @tc.name: PrintManagerClientTest_0082
1651 * @tc.desc: Off failed2
1652 * @tc.type: FUNC
1653 * @tc.require:
1654 */
1655 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0082, TestSize.Level1)
1656 {
1657 std::string testTaskId = "taskId-123";
1658 std::string testType = "type";
1659
1660 PrintManagerClient::GetInstance()->LoadServerSuccess();
1661 PrintManagerClient::GetInstance()->ResetProxy();
1662 int32_t ret = PrintManagerClient::GetInstance()->Off(testTaskId, testType);
1663 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1664 }
1665
1666 /**
1667 * @tc.name: PrintManagerClientTest_0083
1668 * @tc.desc: StartPrint failed case.
1669 * @tc.type: FUNC
1670 * @tc.require:
1671 */
1672 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0083, TestSize.Level1)
1673 {
1674 std::string testTaskId = "taskId-123";
1675 std::string testType = "type";
1676
1677 PrintManagerClient::GetInstance()->LoadServerFail();
1678 PrintManagerClient::GetInstance()->ResetProxy();
1679 int32_t ret = PrintManagerClient::GetInstance()->Off(testTaskId, testType);
1680 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
1681 }
1682
1683 /**
1684 * @tc.name: PrintManagerClientTest_0084
1685 * @tc.desc: StartDiscoverPrinter
1686 * @tc.type: FUNC
1687 * @tc.require:
1688 */
1689 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0084, TestSize.Level1)
1690 {
1691 std::string testTaskId = "taskId-123";
1692 std::string testType = "type";
1693
1694 auto service = std::make_shared<MockPrintService>();
1695 EXPECT_NE(service, nullptr);
1696 EXPECT_CALL(*service, Off(_, _)).Times(1);
1697 ON_CALL(*service, Off).WillByDefault(
__anone9e578951702(const std::string taskId, const std::string &type) 1698 [&testTaskId, &testType](const std::string taskId, const std::string &type) {
1699 EXPECT_EQ(testTaskId, taskId);
1700 EXPECT_EQ(testType, type);
1701 return E_PRINT_NONE;
1702 });
1703 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1704 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1705 CallRemoteObject(service, obj, dr);
1706 PrintManagerClient::GetInstance()->LoadServerSuccess();
1707 int32_t ret = PrintManagerClient::GetInstance()->Off(testTaskId, testType);
1708 EXPECT_EQ(ret, E_PRINT_NONE);
1709 EXPECT_NE(dr, nullptr);
1710 dr->OnRemoteDied(obj);
1711 }
1712
1713 /**
1714 * @tc.name: PrintManagerClientTest_0085
1715 * @tc.desc: RegisterExtCallback: invalid callback id of ext cb
1716 * @tc.type: FUNC
1717 * @tc.require:
1718 */
1719 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0085, TestSize.Level1)
1720 {
1721 std::string testExtensionId = "com.example.ext";
1722 uint32_t testCallbackId = PRINT_EXTCB_MAX + 100;
1723 PrintExtCallback testCb = nullptr;
1724
1725 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1726 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
1727 }
1728
1729 /**
1730 * @tc.name: PrintManagerClientTest_0086
1731 * @tc.desc: RegisterExtCallback: invalid callback id of job cb
1732 * @tc.type: FUNC
1733 * @tc.require:
1734 */
1735 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0086, TestSize.Level1)
1736 {
1737 std::string testExtensionId = "com.example.ext";
1738 uint32_t testCallbackId = PRINT_EXTCB_MAX + 100;
1739 PrintJobCallback testCb = nullptr;
1740
1741 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1742 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
1743 }
1744
1745 /**
1746 * @tc.name: PrintManagerClientTest_0087
1747 * @tc.desc: RegisterExtCallback: invalid callback id of printer cap cb
1748 * @tc.type: FUNC
1749 * @tc.require:
1750 */
1751 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0087, TestSize.Level1)
1752 {
1753 std::string testExtensionId = "com.example.ext";
1754 uint32_t testCallbackId = PRINT_EXTCB_MAX + 100;
1755 PrinterCapabilityCallback testCb = nullptr;
1756
1757 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1758 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
1759 }
1760
1761 /**
1762 * @tc.name: PrintManagerClientTest_0088
1763 * @tc.desc: RegisterExtCallback: invalid callback id of printer cb
1764 * @tc.type: FUNC
1765 * @tc.require:
1766 */
1767 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0088, TestSize.Level1)
1768 {
1769 std::string testExtensionId = "com.example.ext";
1770 uint32_t testCallbackId = PRINT_EXTCB_MAX + 100;
1771 PrinterCallback testCb = nullptr;
1772
1773 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1774 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
1775 }
1776
1777 /**
1778 * @tc.name: PrintManagerClientTest_0089
1779 * @tc.desc: RegisterExtCallback: load serve failed for ext cb
1780 * @tc.type: FUNC
1781 * @tc.require:
1782 */
1783 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0089, TestSize.Level1)
1784 {
1785 std::string testExtensionId = "com.example.ext";
1786 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1787 PrintExtCallback testCb = nullptr;
1788
1789 PrintManagerClient::GetInstance()->LoadServerFail();
1790 PrintManagerClient::GetInstance()->ResetProxy();
1791 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1792 }
1793
1794 /**
1795 * @tc.name: PrintManagerClientTest_0090
1796 * @tc.desc: RegisterExtCallback: load serve failed for job cb
1797 * @tc.type: FUNC
1798 * @tc.require:
1799 */
1800 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0090, TestSize.Level1)
1801 {
1802 std::string testExtensionId = "com.example.ext";
1803 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1804 PrintJobCallback testCb = nullptr;
1805
1806 PrintManagerClient::GetInstance()->LoadServerFail();
1807 PrintManagerClient::GetInstance()->ResetProxy();
1808 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1809 }
1810
1811 /**
1812 * @tc.name: PrintManagerClientTest_0091
1813 * @tc.desc: RegisterExtCallback: load serve failed for printer cb
1814 * @tc.type: FUNC
1815 * @tc.require:
1816 */
1817 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0091, TestSize.Level1)
1818 {
1819 std::string testExtensionId = "com.example.ext";
1820 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1821 PrinterCallback testCb = nullptr;
1822
1823 PrintManagerClient::GetInstance()->LoadServerFail();
1824 PrintManagerClient::GetInstance()->ResetProxy();
1825 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1826 }
1827
1828 /**
1829 * @tc.name: PrintManagerClientTest_0092
1830 * @tc.desc: RegisterExtCallback: load serve failed for printer cap cb
1831 * @tc.type: FUNC
1832 * @tc.require:
1833 */
1834 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0092, TestSize.Level1)
1835 {
1836 std::string testExtensionId = "com.example.ext";
1837 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1838 PrinterCapabilityCallback testCb = nullptr;
1839
1840 PrintManagerClient::GetInstance()->LoadServerFail();
1841 PrintManagerClient::GetInstance()->ResetProxy();
1842 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1843 }
1844
1845 /**
1846 * @tc.name: PrintManagerClientTest_0093
1847 * @tc.desc: RegisterExtCallback: without proxy for ext cb
1848 * @tc.type: FUNC
1849 * @tc.require:
1850 */
1851 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0093, TestSize.Level1)
1852 {
1853 std::string testExtensionId = "com.example.ext";
1854 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1855 PrintExtCallback testCb = nullptr;
1856
1857 PrintManagerClient::GetInstance()->LoadServerSuccess();
1858 PrintManagerClient::GetInstance()->ResetProxy();
1859 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1860 }
1861
1862 /**
1863 * @tc.name: PrintManagerClientTest_0094
1864 * @tc.desc: RegisterExtCallback: without proxy for job cb
1865 * @tc.type: FUNC
1866 * @tc.require:
1867 */
1868 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0094, TestSize.Level1)
1869 {
1870 std::string testExtensionId = "com.example.ext";
1871 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1872 PrintJobCallback testCb = nullptr;
1873
1874 PrintManagerClient::GetInstance()->LoadServerSuccess();
1875 PrintManagerClient::GetInstance()->ResetProxy();
1876 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1877 }
1878
1879 /**
1880 * @tc.name: PrintManagerClientTest_0095
1881 * @tc.desc: RegisterExtCallback: without proxy for printer cb
1882 * @tc.type: FUNC
1883 * @tc.require:
1884 */
1885 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0095, TestSize.Level1)
1886 {
1887 std::string testExtensionId = "com.example.ext";
1888 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1889 PrinterCallback testCb = nullptr;
1890
1891 PrintManagerClient::GetInstance()->LoadServerSuccess();
1892 PrintManagerClient::GetInstance()->ResetProxy();
1893 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1894 }
1895
1896 /**
1897 * @tc.name: PrintManagerClientTest_0096
1898 * @tc.desc: RegisterExtCallback: without proxy for printer cap cb
1899 * @tc.type: FUNC
1900 * @tc.require:
1901 */
1902 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0096, TestSize.Level1)
1903 {
1904 std::string testExtensionId = "com.example.ext";
1905 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1906 PrinterCapabilityCallback testCb = nullptr;
1907
1908 PrintManagerClient::GetInstance()->LoadServerSuccess();
1909 PrintManagerClient::GetInstance()->ResetProxy();
1910 PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1911 }
1912
1913 /**
1914 * @tc.name: PrintManagerClientTest_0097
1915 * @tc.desc: RegisterExtCallback: ok for ext cb
1916 * @tc.type: FUNC
1917 * @tc.require:
1918 */
1919 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0097, TestSize.Level1)
1920 {
1921 std::string testExtensionId = "com.example.ext";
1922 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1923 PrintExtCallback testCb = nullptr;
1924
1925 auto service = std::make_shared<MockPrintService>();
1926 EXPECT_NE(service, nullptr);
1927 EXPECT_CALL(*service, RegisterExtCallback(_, _)).Times(1).WillOnce(Return(E_PRINT_NONE));
1928 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1929 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1930 CallRemoteObject(service, obj, dr);
1931 PrintManagerClient::GetInstance()->LoadServerSuccess();
1932 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1933 EXPECT_EQ(ret, E_PRINT_NONE);
1934 EXPECT_NE(dr, nullptr);
1935 dr->OnRemoteDied(obj);
1936 }
1937
1938 /**
1939 * @tc.name: PrintManagerClientTest_0098
1940 * @tc.desc: RegisterExtCallback: ok for job cb
1941 * @tc.type: FUNC
1942 * @tc.require:
1943 */
1944 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0098, TestSize.Level1)
1945 {
1946 std::string testExtensionId = "com.example.ext";
1947 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1948 PrintJobCallback testCb = nullptr;
1949
1950 auto service = std::make_shared<MockPrintService>();
1951 EXPECT_NE(service, nullptr);
1952 EXPECT_CALL(*service, RegisterExtCallback(_, _)).Times(1).WillOnce(Return(E_PRINT_NONE));
1953 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1954 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1955 CallRemoteObject(service, obj, dr);
1956 PrintManagerClient::GetInstance()->LoadServerSuccess();
1957 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1958 EXPECT_EQ(ret, E_PRINT_NONE);
1959 EXPECT_NE(dr, nullptr);
1960 dr->OnRemoteDied(obj);
1961 }
1962
1963 /**
1964 * @tc.name: PrintManagerClientTest_0099
1965 * @tc.desc: RegisterExtCallback: ok for printer cb
1966 * @tc.type: FUNC
1967 * @tc.require:
1968 */
1969 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0099, TestSize.Level1)
1970 {
1971 std::string testExtensionId = "com.example.ext";
1972 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1973 PrinterCallback testCb = nullptr;
1974
1975 auto service = std::make_shared<MockPrintService>();
1976 EXPECT_NE(service, nullptr);
1977 EXPECT_CALL(*service, RegisterExtCallback(_, _)).Times(1).WillOnce(Return(E_PRINT_NONE));
1978 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
1979 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
1980 CallRemoteObject(service, obj, dr);
1981 PrintManagerClient::GetInstance()->LoadServerSuccess();
1982 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
1983 EXPECT_EQ(ret, E_PRINT_NONE);
1984 EXPECT_NE(dr, nullptr);
1985 dr->OnRemoteDied(obj);
1986 }
1987
1988 /**
1989 * @tc.name: PrintManagerClientTest_0100
1990 * @tc.desc: RegisterExtCallback: ok for printer cap cb
1991 * @tc.type: FUNC
1992 * @tc.require:
1993 */
1994 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0100, TestSize.Level1)
1995 {
1996 std::string testExtensionId = "com.example.ext";
1997 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
1998 PrinterCapabilityCallback testCb = nullptr;
1999
2000 auto service = std::make_shared<MockPrintService>();
2001 EXPECT_NE(service, nullptr);
2002 EXPECT_CALL(*service, RegisterExtCallback(_, _)).Times(1).WillOnce(Return(E_PRINT_NONE));
2003 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
2004 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
2005 CallRemoteObject(service, obj, dr);
2006 PrintManagerClient::GetInstance()->LoadServerSuccess();
2007 int32_t ret = PrintManagerClient::GetInstance()->RegisterExtCallback(testExtensionId, testCallbackId, testCb);
2008 EXPECT_EQ(ret, E_PRINT_NONE);
2009 EXPECT_NE(dr, nullptr);
2010 dr->OnRemoteDied(obj);
2011 }
2012
2013 /**
2014 * @tc.name: PrintManagerClientTest_0101
2015 * @tc.desc: UnregisterAllExtCallback
2016 * @tc.type: FUNC
2017 * @tc.require:
2018 */
2019 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0101, TestSize.Level1)
2020 {
2021 std::string testExtensionId = "com.example.ext";
2022
2023 PrintManagerClient::GetInstance()->LoadServerFail();
2024 PrintManagerClient::GetInstance()->ResetProxy();
2025 int32_t ret = PrintManagerClient::GetInstance()->UnregisterAllExtCallback(testExtensionId);
2026 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2027 }
2028
2029 /**
2030 * @tc.name: PrintManagerClientTest_0102
2031 * @tc.desc: UnregisterAllExtCallback
2032 * @tc.type: FUNC
2033 * @tc.require:
2034 */
2035 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0102, TestSize.Level1)
2036 {
2037 std::string testExtensionId = "com.example.ext";
2038
2039 PrintManagerClient::GetInstance()->LoadServerSuccess();
2040 PrintManagerClient::GetInstance()->ResetProxy();
2041 int32_t ret = PrintManagerClient::GetInstance()->UnregisterAllExtCallback(testExtensionId);
2042 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2043 }
2044
2045 /**
2046 * @tc.name: PrintManagerClientTest_0103
2047 * @tc.desc: StartPrint failed case.
2048 * @tc.type: FUNC
2049 * @tc.require:
2050 */
2051 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0103, TestSize.Level1)
2052 {
2053 std::string testExtensionId = "com.example.ext";
2054
2055 PrintManagerClient::GetInstance()->LoadServerFail();
2056 auto service = std::make_shared<MockPrintService>();
2057 EXPECT_NE(service, nullptr);
2058 EXPECT_CALL(*service, UnregisterAllExtCallback(_)).Times(1).WillOnce(Return(E_PRINT_NONE));
2059 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
2060 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
2061 CallRemoteObject(service, obj, dr);
2062 int32_t ret = PrintManagerClient::GetInstance()->UnregisterAllExtCallback(testExtensionId);
2063 EXPECT_EQ(ret, E_PRINT_NONE);
2064 }
2065
2066 /**
2067 * @tc.name: PrintManagerClientTest_0104
2068 * @tc.desc: StartDiscoverPrinter
2069 * @tc.type: FUNC
2070 * @tc.require:
2071 */
2072 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0104, TestSize.Level1)
2073 {
2074 std::string testExtensionId = "com.example.ext";
2075
2076 auto service = std::make_shared<MockPrintService>();
2077 EXPECT_NE(service, nullptr);
2078 EXPECT_CALL(*service, UnregisterAllExtCallback(_)).Times(1).WillOnce(Return(E_PRINT_NONE));
2079 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
2080 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
2081 CallRemoteObject(service, obj, dr);
2082 PrintManagerClient::GetInstance()->LoadServerSuccess();
2083 int32_t ret = PrintManagerClient::GetInstance()->UnregisterAllExtCallback(testExtensionId);
2084 EXPECT_EQ(ret, E_PRINT_NONE);
2085 EXPECT_NE(dr, nullptr);
2086 dr->OnRemoteDied(obj);
2087 }
2088
2089 /**
2090 * @tc.name: PrintManagerClientTest_0105
2091 * @tc.desc: QueryAllExtension
2092 * @tc.type: FUNC
2093 * @tc.require:
2094 */
2095 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0105, TestSize.Level1)
2096 {
2097 std::string testExtensionId = "com.example.ext";
2098 PrintManagerClient::GetInstance()->LoadServerFail();
2099 PrintManagerClient::GetInstance()->ResetProxy();
2100 int32_t ret = PrintManagerClient::GetInstance()->LoadExtSuccess(testExtensionId);
2101 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2102 }
2103
2104 /**
2105 * @tc.name: PrintManagerClientTest_0106
2106 * @tc.desc: QueryAllExtension_NA1
2107 * @tc.type: FUNC
2108 * @tc.require:
2109 */
2110 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0106, TestSize.Level1)
2111 {
2112 std::string testExtensionId = "com.example.ext";
2113 PrintManagerClient::GetInstance()->LoadServerSuccess();
2114 PrintManagerClient::GetInstance()->ResetProxy();
2115 int32_t ret = PrintManagerClient::GetInstance()->LoadExtSuccess(testExtensionId);
2116 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2117 }
2118
2119 /**
2120 * @tc.name: PrintManagerClientTest_0107
2121 * @tc.desc: StartPrint failed case.
2122 * @tc.type: FUNC
2123 * @tc.require:
2124 */
2125 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0107, TestSize.Level1)
2126 {
2127 std::string testExtensionId = "com.example.ext";
2128 PrintManagerClient::GetInstance()->LoadServerFail();
2129 auto service = std::make_shared<MockPrintService>();
2130 EXPECT_NE(service, nullptr);
2131 EXPECT_CALL(*service, LoadExtSuccess(_)).Times(1).WillOnce(Return(E_PRINT_NONE));
2132 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
2133 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
2134 CallRemoteObject(service, obj, dr);
2135 int32_t ret = PrintManagerClient::GetInstance()->LoadExtSuccess(testExtensionId);
2136 EXPECT_EQ(ret, E_PRINT_NONE);
2137 }
2138
2139 /**
2140 * @tc.name: PrintManagerClientTest_0108
2141 * @tc.desc: StartDiscoverPrinter
2142 * @tc.type: FUNC
2143 * @tc.require:
2144 */
2145 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0108, TestSize.Level1)
2146 {
2147 std::string testExtensionId = "com.example.ext";
2148 auto service = std::make_shared<MockPrintService>();
2149 EXPECT_NE(service, nullptr);
2150 EXPECT_CALL(*service, LoadExtSuccess(_)).Times(1).WillOnce(Return(E_PRINT_NONE));
2151 sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
2152 sptr<IRemoteObject::DeathRecipient> dr = nullptr;
2153 CallRemoteObject(service, obj, dr);
2154 PrintManagerClient::GetInstance()->LoadServerSuccess();
2155 int32_t ret = PrintManagerClient::GetInstance()->LoadExtSuccess(testExtensionId);
2156 EXPECT_EQ(ret, E_PRINT_NONE);
2157 EXPECT_NE(dr, nullptr);
2158 dr->OnRemoteDied(obj);
2159 }
2160
2161 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0112, TestSize.Level1)
2162 {
2163 std::string printerUri;
2164 std::string printerName;
2165 std::string printerMake;
2166 PrintManagerClient::GetInstance()->LoadServerFail();
2167 int32_t ret = PrintManagerClient::GetInstance()->AddPrinterToCups(printerUri, printerName, printerMake);
2168 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2169 }
2170
2171 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0113, TestSize.Level1)
2172 {
2173 std::string printerUri;
2174 std::string printerName;
2175 std::string printerMake;
2176 PrintManagerClient::GetInstance()->LoadServerSuccess();
2177 PrintManagerClient::GetInstance()->ResetProxy();
2178 int32_t ret = PrintManagerClient::GetInstance()->AddPrinterToCups(printerUri, printerName, printerMake);
2179 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2180 }
2181
2182 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0114, TestSize.Level1)
2183 {
2184 std::string printerUri;
2185 std::string printerName;
2186 std::string printerMake;
2187 PrintManagerClient::GetInstance()->LoadServerFail();
2188 PrintManagerClient::GetInstance()->ResetProxy();
2189 int32_t ret = PrintManagerClient::GetInstance()->AddPrinterToCups(printerUri, printerName, printerMake);
2190 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2191 }
2192
2193 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0115, TestSize.Level1)
2194 {
2195 std::string printerUri;
2196 std::string printerName;
2197 std::string printerMake;
2198 PrintManagerClient::GetInstance()->LoadServerSuccess();
2199 int32_t ret = PrintManagerClient::GetInstance()->AddPrinterToCups(printerUri, printerName, printerMake);
2200 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2201 }
2202
2203 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0116, TestSize.Level1)
2204 {
2205 std::string printerUri;
2206 std::string printerId;
2207 PrinterCapability printerCaps;
2208 PrintManagerClient::GetInstance()->LoadServerFail();
2209 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
2210 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2211 }
2212
2213 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0117, TestSize.Level1)
2214 {
2215 std::string printerUri;
2216 std::string printerId;
2217 PrinterCapability printerCaps;
2218 PrintManagerClient::GetInstance()->LoadServerSuccess();
2219 PrintManagerClient::GetInstance()->ResetProxy();
2220 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
2221 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2222 }
2223
2224 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0118, TestSize.Level1)
2225 {
2226 std::string printerUri;
2227 std::string printerId;
2228 PrinterCapability printerCaps;
2229 PrintManagerClient::GetInstance()->LoadServerFail();
2230 PrintManagerClient::GetInstance()->ResetProxy();
2231 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
2232 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2233 }
2234
2235 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0119, TestSize.Level1)
2236 {
2237 std::string printerUri;
2238 std::string printerId;
2239 PrinterCapability printerCaps;
2240 PrintManagerClient::GetInstance()->LoadServerSuccess();
2241 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
2242 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2243 }
2244
2245 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0121, TestSize.Level1)
2246 {
2247 OHOS::Print::PrinterInfo printerInfo;
2248 std::string printerId = "printId-123";
2249 printerInfo.SetPrinterId(printerId);
2250 printerInfo.SetPrinterName("1");
2251 printerInfo.SetPrinterIcon(1);
2252 printerInfo.SetPrinterState(1);
2253 printerInfo.SetDescription("111");
2254 const PrinterCapability capability;
2255 printerInfo.SetCapability(capability);
2256 const std::string option = "1";
2257 printerInfo.SetOption(option);
2258
2259 PrintManagerClient::GetInstance()->LoadServerSuccess();
2260 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterInfoByPrinterId(printerId, printerInfo);
2261 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2262 }
2263
2264 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0122, TestSize.Level1)
2265 {
2266 std::vector<std::string> printerNameList;
2267 printerNameList.push_back("1");
2268 PrintManagerClient::GetInstance()->LoadServerSuccess();
2269 int32_t ret = PrintManagerClient::GetInstance()->QueryAddedPrinter(printerNameList);
2270 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2271 }
2272
2273 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0123, TestSize.Level1)
2274 {
2275 std::string printerId = "printId-123";
2276 std::vector<std::string> keyList;
2277 std::vector<std::string> valueList;
2278 keyList.push_back("1");
2279 valueList.push_back("1");
2280 PrintManagerClient::GetInstance()->LoadServerSuccess();
2281 int32_t ret = PrintManagerClient::GetInstance()->QueryPrinterProperties(printerId, keyList, valueList);
2282 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2283 }
2284
2285 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0124, TestSize.Level1)
2286 {
2287 std::string testPrintJobId = "jobId-123";
2288 PrintJob testPrintJob;
2289 testPrintJob.SetJobId("jobId-123");
2290 PrintManagerClient::GetInstance()->LoadServerSuccess();
2291 int32_t ret = PrintManagerClient::GetInstance()->StartNativePrintJob(testPrintJob);
2292 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2293 }
2294
2295 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0125, TestSize.Level1)
2296 {
2297 std::string printJobName = "jobName-123";
2298 sptr<IPrintCallback> testListener;
2299 PrintAttributes testPrintAttributes;
2300 PrintManagerClient::GetInstance()->LoadServerSuccess();
2301 int32_t ret = PrintManagerClient::GetInstance()->Print(printJobName, testListener, testPrintAttributes);
2302 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
2303 }
2304
2305 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0126, TestSize.Level1)
2306 {
2307 std::string printJobName = "jobName-123";
2308 sptr<IPrintCallback> testListener;
2309 PrintAttributes testPrintAttributes;
2310 void* contextToken = nullptr;
2311 PrintManagerClient::GetInstance()->LoadServerSuccess();
2312 int32_t ret = PrintManagerClient::GetInstance()->
2313 Print(printJobName, testListener, testPrintAttributes, contextToken);
2314 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
2315 }
2316
2317 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0127, TestSize.Level1)
2318 {
2319 std::string printJobName = "jobName-123";
2320 sptr<IPrintCallback> testListener;
2321 PrintAttributes testPrintAttributes;
2322 std::string taskId = "1";
2323 PrintManagerClient::GetInstance()->LoadServerSuccess();
2324 int32_t ret = PrintManagerClient::GetInstance()->
2325 Print(printJobName, testListener, testPrintAttributes, taskId);
2326 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
2327 }
2328
2329 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0128, TestSize.Level1)
2330 {
2331 std::string printJobName = "jobName-123";
2332 sptr<IPrintCallback> testListener;
2333 PrintAttributes testPrintAttributes;
2334 std::string taskId = "1";
2335 void* contextToken = nullptr;
2336 PrintManagerClient::GetInstance()->LoadServerSuccess();
2337 int32_t ret = PrintManagerClient::GetInstance()->
2338 Print(printJobName, testListener, testPrintAttributes, taskId, contextToken);
2339 EXPECT_EQ(ret, E_PRINT_INVALID_PARAMETER);
2340 }
2341
2342 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0129, TestSize.Level1)
2343 {
2344 std::string jobId = "1";
2345 PrintAttributes testPrintAttributes;
2346 uint32_t fd = 0;
2347 PrintManagerClient::GetInstance()->LoadServerSuccess();
2348 int32_t ret = PrintManagerClient::GetInstance()->StartGetPrintFile(jobId, testPrintAttributes, fd);
2349 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2350 }
2351
2352 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0130, TestSize.Level1)
2353 {
2354 std::string jobId = "1";
2355 std::string type = "";
2356 PrintManagerClient::GetInstance()->LoadServerSuccess();
2357 int32_t ret = PrintManagerClient::GetInstance()->NotifyPrintService(jobId, type);
2358 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2359 }
2360
2361 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0131, TestSize.Level1)
2362 {
2363 char callerFunN[] = "testName";
2364 char* callerFunName = callerFunN;
__anone9e578951802(sptr<IPrintService>) 2365 std::function<int32_t(sptr<IPrintService>)> func = [](sptr<IPrintService>) -> int32_t {
2366 return 0;
2367 };
2368 PrintManagerClient::GetInstance()->LoadServerSuccess();
2369 int32_t ret = PrintManagerClient::GetInstance()->runBase(callerFunName, func);
2370 EXPECT_EQ(ret, E_PRINT_NONE);
2371 }
2372
2373 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0132, TestSize.Level1)
2374 {
2375 std::string type = "test";
2376 NativePrinterChangeCallback cb = nullptr;
2377 PrintManagerClient::GetInstance()->LoadServerSuccess();
2378 int32_t ret = PrintManagerClient::GetInstance()->SetNativePrinterChangeCallback(type, cb);
2379 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2380 }
2381
2382 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0133, TestSize.Level1)
2383 {
2384 PrintManagerClient::GetInstance()->LoadServerSuccess();
2385 int32_t ret = PrintManagerClient::GetInstance()->Init();
2386 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2387 }
2388
2389 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0134, TestSize.Level1)
2390 {
2391 MockPrintManagerClient mockPrintManagerClient;
2392 int32_t ret = mockPrintManagerClient.Init();
2393 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2394 }
2395
2396 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0135, TestSize.Level1)
2397 {
2398 MockPrintManagerClient mockPrintManagerClient;
2399 std::vector<std::string> testFileList = {"file://data/print/a.png",
2400 "file://data/print/b.png", "file://data/print/c.png"};
2401 std::vector<uint32_t> testFdList = {1, 2};
2402 std::string testTaskId = "2";
2403 int32_t ret = mockPrintManagerClient.StartPrint(testFileList, testFdList, testTaskId);
2404 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2405 }
2406
2407 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0137, TestSize.Level1)
2408 {
2409 MockPrintManagerClient mockPrintManagerClient;
2410 std::string testTaskId = "2";
2411 int32_t ret = mockPrintManagerClient.StopPrint(testTaskId);
2412 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2413 }
2414
2415 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0138, TestSize.Level1)
2416 {
2417 MockPrintManagerClient mockPrintManagerClient;
2418 std::string printerId = "2";
2419 int32_t ret = mockPrintManagerClient.ConnectPrinter(printerId);
2420 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2421 }
2422
2423 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0139, TestSize.Level1)
2424 {
2425 MockPrintManagerClient mockPrintManagerClient;
2426 std::string printerId = "2";
2427 int32_t ret = mockPrintManagerClient.DisconnectPrinter(printerId);
2428 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2429 }
2430
2431 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0140, TestSize.Level1)
2432 {
2433 MockPrintManagerClient mockPrintManagerClient;
2434 std::vector<PrintExtensionInfo> extensionInfos;
2435 int32_t ret = mockPrintManagerClient.QueryAllExtension(extensionInfos);
2436 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2437 }
2438
2439 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0141, TestSize.Level1)
2440 {
2441 MockPrintManagerClient mockPrintManagerClient;
2442 std::vector<std::string> testExtensionList = {"extensionId-1", "extensionId-2"};
2443 int32_t ret = mockPrintManagerClient.StartDiscoverPrinter(testExtensionList);
2444 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2445 }
2446
2447 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0142, TestSize.Level1)
2448 {
2449 MockPrintManagerClient mockPrintManagerClient;
2450 int32_t ret = E_PRINT_NONE;
2451 mockPrintManagerClient.StopDiscoverPrinter();
2452 PrintJob jobinfo;
2453 mockPrintManagerClient.StartPrintJob(jobinfo);
2454 std::string testJobId = "jobId-1";
2455 mockPrintManagerClient.CancelPrintJob(testJobId);
2456 std::vector<PrinterInfo> printerInfos;
2457 mockPrintManagerClient.AddPrinters(printerInfos);
2458 std::vector<std::string> testPrinterIds = {"printerId-1", "printerId-2"};
2459 mockPrintManagerClient.RemovePrinters(testPrinterIds);
2460 mockPrintManagerClient.UpdatePrinters(printerInfos);
2461 std::string printerId = "2";
2462 uint32_t testState = 6;
2463 ret = mockPrintManagerClient.UpdatePrinterState(printerId, testState);
2464 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2465 std::string jobId = "jobId-1";
2466 uint32_t testSubState = 6;
2467 ret = mockPrintManagerClient.UpdatePrintJobStateOnlyForSystemApp(jobId, testState, testSubState);
2468 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2469 }
2470
2471 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0143, TestSize.Level1)
2472 {
2473 MockPrintManagerClient mockPrintManagerClient;
2474 int32_t ret = E_PRINT_NONE;
2475 std::string extensionId = "extensionId-1";
2476 mockPrintManagerClient.UpdateExtensionInfo(extensionId);
2477 PrintJob jobinfo;
2478 std::string previewFilePath = "/data/temp/preview.png";
2479 mockPrintManagerClient.RequestPreview(jobinfo, previewFilePath);
2480 std::string printerId = "2";
2481 mockPrintManagerClient.QueryPrinterCapability(printerId);
2482 PrinterInfo printerInfo;
2483 mockPrintManagerClient.QueryPrinterInfoByPrinterId(printerId, printerInfo);
2484 std::vector<std::string> printerNameList;
2485 printerNameList.push_back("1");
2486 mockPrintManagerClient.QueryAddedPrinter(printerNameList);
2487 std::vector<std::string> keyList;
2488 std::vector<std::string> valueList;
2489 keyList.push_back("1");
2490 valueList.push_back("1");
2491 mockPrintManagerClient.QueryPrinterProperties(printerId, keyList, valueList);
2492 mockPrintManagerClient.StartNativePrintJob(jobinfo);
2493 std::vector<PrintJob> printJobs;
2494 ret = mockPrintManagerClient.QueryAllPrintJob(printJobs);
2495 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2496 std::vector<PrinterInfo> printers;
2497 ret = mockPrintManagerClient.DiscoverUsbPrinters(printers);
2498 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2499 }
2500
2501 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0144, TestSize.Level1)
2502 {
2503 PrintManagerClient::GetInstance()->LoadServerSuccess();
2504 uint32_t event = 0;
2505 std::string jobId = "jobId";
2506 int32_t ret = PrintManagerClient::GetInstance()->NotifyPrintServiceEvent(jobId, event);
2507 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2508 }
2509
2510 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0145, TestSize.Level1)
2511 {
2512 PrintManagerClient::GetInstance()->LoadServerFail();
2513 uint32_t event = 0;
2514 std::string jobId = "jobId";
2515 int32_t ret = PrintManagerClient::GetInstance()->NotifyPrintServiceEvent(jobId, event);
2516 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2517 }
2518
2519 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0146, TestSize.Level1)
2520 {
2521 MockPrintManagerClient mockPrintManagerClient;
2522 uint32_t event = 0;
2523 std::string jobId = "jobId";
2524 int32_t ret = E_PRINT_NONE;
2525 mockPrintManagerClient.NotifyPrintServiceEvent(jobId, event);
2526 std::string testPrintJobId = "jobId-123";
2527 PrintJob testPrintJob;
2528 mockPrintManagerClient.QueryPrintJobById(testPrintJobId, testPrintJob);
2529 std::string printerUri;
2530 std::string printerName;
2531 std::string printerMake;
2532 mockPrintManagerClient.AddPrinterToCups(printerUri, printerName, printerMake);
2533 std::string printerId;
2534 PrinterCapability printerCaps;
2535 mockPrintManagerClient.QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
2536 std::string testTaskId = "taskId-123";
2537 std::string testType = "type";
2538 sptr<IPrintCallback> testListener;
2539 mockPrintManagerClient.On(testTaskId, testType, testListener);
2540 mockPrintManagerClient.Off(testTaskId, testType);
2541 std::string type = "";
2542 mockPrintManagerClient.NotifyPrintService(jobId, type);
2543 char callerFunN[] = "testName";
2544 char* callerFunName = callerFunN;
__anone9e578951902(sptr<IPrintService>) 2545 std::function<int32_t(sptr<IPrintService>)> func = [](sptr<IPrintService>) -> int32_t {
2546 return 0;
2547 };
2548 mockPrintManagerClient.runBase(callerFunName, func);
2549 std::string testExtensionId = "com.example.ext";
2550 uint32_t testCallbackId = PRINT_EXTCB_START_DISCOVERY;
2551 PrinterCapabilityCallback testCb = nullptr;
2552 mockPrintManagerClient.RegisterExtCallback(testExtensionId, testCallbackId, testCb);
2553 PrintJobCallback jobCb = nullptr;
2554 mockPrintManagerClient.RegisterExtCallback(testExtensionId, testCallbackId, jobCb);
2555 PrinterCapabilityCallback capCb = nullptr;
2556 mockPrintManagerClient.RegisterExtCallback(testExtensionId, testCallbackId, capCb);
2557 PrinterCallback printerCb = nullptr;
2558 mockPrintManagerClient.RegisterExtCallback(testExtensionId, testCallbackId, printerCb);
2559 mockPrintManagerClient.UnregisterAllExtCallback(testExtensionId);
2560 NativePrinterChangeCallback cb = nullptr;
2561 ret = mockPrintManagerClient.SetNativePrinterChangeCallback(type, cb);
2562 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2563 ret = mockPrintManagerClient.LoadExtSuccess(testExtensionId);
2564 EXPECT_EQ(ret, E_PRINT_RPC_FAILURE);
2565 }
2566
2567 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0147, TestSize.Level1)
2568 {
2569 PrintManagerClient::GetInstance()->LoadServerSuccess();
2570 std::string printerId = "printId-123";
2571 uint32_t type = 1;
2572 int32_t ret = PrintManagerClient::GetInstance()->SetDefaultPrinter(printerId, type);
2573 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2574 }
2575
2576 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0148, TestSize.Level1)
2577 {
2578 PrintManagerClient::GetInstance()->LoadServerFail();
2579 std::string printerId = "printId-123";
2580 uint32_t type = 1;
2581 int32_t ret = PrintManagerClient::GetInstance()->SetDefaultPrinter(printerId, type);
2582 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2583 }
2584
2585 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0149, TestSize.Level1)
2586 {
2587 PrintManagerClient::GetInstance()->LoadServerSuccess();
2588 std::string printerName;
2589 int32_t ret = PrintManagerClient::GetInstance()->DeletePrinterFromCups(printerName);
2590 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2591 }
2592
2593 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0150, TestSize.Level1)
2594 {
2595 PrintManagerClient::GetInstance()->LoadServerFail();
2596 std::string printerName;
2597 int32_t ret = PrintManagerClient::GetInstance()->DeletePrinterFromCups(printerName);
2598 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2599 }
2600
2601 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0151, TestSize.Level1)
2602 {
2603 PrintManagerClient::GetInstance()->LoadServerSuccess();
2604 std::string printerId = "printId-123";
2605 std::string printPreference = "";
2606 int32_t ret = PrintManagerClient::GetInstance()->GetPrinterPreference(printerId, printPreference);
2607 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2608 }
2609
2610 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0152, TestSize.Level1)
2611 {
2612 PrintManagerClient::GetInstance()->LoadServerFail();
2613 std::string printerId = "printId-123";
2614 std::string printPreference = "";
2615 int32_t ret = PrintManagerClient::GetInstance()->GetPrinterPreference(printerId, printPreference);
2616 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2617 }
2618
2619 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0153, TestSize.Level1)
2620 {
2621 PrintManagerClient::GetInstance()->LoadServerSuccess();
2622 std::string printerId = "printId-123";
2623 std::string printPreference = "";
2624 int32_t ret = PrintManagerClient::GetInstance()->SetPrinterPreference(printerId, printPreference);
2625 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2626 }
2627
2628 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0154, TestSize.Level1)
2629 {
2630 PrintManagerClient::GetInstance()->LoadServerFail();
2631 std::string printerId = "printId-123";
2632 std::string printPreference = "";
2633 int32_t ret = PrintManagerClient::GetInstance()->SetPrinterPreference(printerId, printPreference);
2634 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2635 }
2636
2637 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0155, TestSize.Level1)
2638 {
2639 std::vector<PrinterInfo> testPrinters;
2640
2641 PrintManagerClient::GetInstance()->LoadServerFail();
2642 int32_t ret = PrintManagerClient::GetInstance()->DiscoverUsbPrinters(testPrinters);
2643 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2644 }
2645
2646 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0156, TestSize.Level1)
2647 {
2648 std::vector<PrinterInfo> testPrinters;
2649
2650 PrintManagerClient::GetInstance()->LoadServerSuccess();
2651 PrintManagerClient::GetInstance()->ResetProxy();
2652 int32_t ret = PrintManagerClient::GetInstance()->DiscoverUsbPrinters(testPrinters);
2653 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2654 }
2655
2656 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0157, TestSize.Level1)
2657 {
2658 std::vector<PrinterInfo> testPrinters;
2659
2660 PrintManagerClient::GetInstance()->LoadServerFail();
2661 PrintManagerClient::GetInstance()->ResetProxy();
2662 int32_t ret = PrintManagerClient::GetInstance()->DiscoverUsbPrinters(testPrinters);
2663 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2664 }
2665
2666 /**
2667 * @tc.name: PrintManagerClientTest_0158
2668 * @tc.desc: AddPrinterToDiscovery failed case.
2669 * @tc.type: FUNC
2670 * @tc.require:
2671 */
2672 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0158, TestSize.Level1)
2673 {
2674 PrinterInfo info;
2675 PrintManagerClient::GetInstance()->LoadServerFail();
2676 PrintManagerClient::GetInstance()->ResetProxy();
2677 int32_t ret = PrintManagerClient::GetInstance()->AddPrinterToDiscovery(info);
2678 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2679 }
2680
2681 /**
2682 * @tc.name: PrintManagerClientTest_0159
2683 * @tc.desc: UpdatePrinterInDiscovery failed case.
2684 * @tc.type: FUNC
2685 * @tc.require:
2686 */
2687 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0159, TestSize.Level1)
2688 {
2689 PrinterInfo info;
2690 PrintManagerClient::GetInstance()->LoadServerFail();
2691 PrintManagerClient::GetInstance()->ResetProxy();
2692 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinterInDiscovery(info);
2693 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2694 }
2695
2696 /**
2697 * @tc.name: PrintManagerClientTest_0160
2698 * @tc.desc: RemovePrinterFromDiscovery failed case.
2699 * @tc.type: FUNC
2700 * @tc.require:
2701 */
2702 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0160, TestSize.Level1)
2703 {
2704 std::string printerId = "test";
2705 PrintManagerClient::GetInstance()->LoadServerFail();
2706 PrintManagerClient::GetInstance()->ResetProxy();
2707 int32_t ret = PrintManagerClient::GetInstance()->RemovePrinterFromDiscovery(printerId);
2708 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2709 }
2710
2711 /**
2712 * @tc.name: PrintManagerClientTest_0161
2713 * @tc.desc: UpdatePrinterInSystem failed case.
2714 * @tc.type: FUNC
2715 * @tc.require:
2716 */
2717 HWTEST_F(PrintManagerClientTest, PrintManagerClientTest_0161, TestSize.Level1)
2718 {
2719 PrinterInfo info;
2720 PrintManagerClient::GetInstance()->LoadServerFail();
2721 PrintManagerClient::GetInstance()->ResetProxy();
2722 int32_t ret = PrintManagerClient::GetInstance()->UpdatePrinterInSystem(info);
2723 EXPECT_EQ(ret, E_PRINT_NO_PERMISSION);
2724 }
2725
2726 } // namespace Print
2727 } // namespace OHOS
2728
