1 /*
2 * Copyright (c) 2024 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 "print_service_ability.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21 namespace OHOS::Print {
22 class PrintServiceAbilityTest : public testing:Test {
23 public:
24 PrintServiceAbility* printServiceAbility;
SetUp()25 void SetUp() override
26 {
27 printServiceAbility = new PrintServiceAbility();
28 }
TearDown()29 void TearDown() override
30 {
31 delete printServiceAbility;
32 printServiceAbility = nullptr
33 }
34 };
35 HWTEST_F(PrintServiceAbilityTest, GetInstance_ShouldReturnDifferentInstance, TestSize.Level0)
36 {
37 sptr<PrintServiceAbility> instance1 = PrintServiceAbility::GetInstance();
38 PrintServiceAbility* temp = new PrintServiceAbility();
39 sptr<PrintServiceAbility> instance2 = PrintServiceAbility::GetInstance();
40 EXPECT_NE(instance1, instance2);
41 delete temp;
42 }
43
TEST_F(nullTest,Init_ShouldReturnFailure_WhenHelperIsNull)44 TEST_F(nullTest, Init_ShouldReturnFailure_WhenHelperIsNull)
45 {
46 PrintServiceAbility printServiceAbility;
47 printServiceAbility.helper_ = nullptr;
48 EXPECT_EQ(printServiceAbility.Init(), E_PRINT_SERVER_FAILURE);
49 }
50
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenHelperIsNotNull)51 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenHelperIsNotNull)
52 {
53 PrintServiceAbility printServiceAbility;
54 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
55 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
56 }
57
TEST_F(nullTest,Init_ShouldReturnFailure_WhenPublishFails)58 TEST_F(nullTest, Init_ShouldReturnFailure_WhenPublishFails)
59 {
60 PrintServiceAbility printServiceAbility;
61 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
62 printServiceAbility.g_publishState = false;
63 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish(_)).WillOnce(Return(false));
64 EXPECT_EQ(printServiceAbility.Init(), E_PRINT_SERVER_FAILURE);
65 }
66
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenPublishSucceeds)67 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenPublishSucceeds)
68 {
69 PrintServiceAbility printServiceAbility;
70 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
71 printServiceAbility.g_publishState = false;
72 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish(_)).WillOnce(Return(true));
73 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
74 }
75
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenPrintSystemDataInitSucceeds)76 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenPrintSystemDataInitSucceeds)
77 {
78 PrintServiceAbility printServiceAbility;
79 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
80 printServiceAbility.g_publishState = true;
81 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish()).WillOnce(Return(true));
82 EXPECT_CALL(*printServiceAbility.printSystemData, Init()).WillOnce(Return());
83 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
84 }
85
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenPreferenceMapInitSucceeds)86 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenPreferenceMapInitSucceeds)
87 {
88 PrintServiceAbility printServiceAbility;
89 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
90 printServiceAbility.g_publishState = true;
91 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish()).WillOnce(Return(true));
92 EXPECT_CALL(*printServiceAbility.printSystemData, Init()).WillOnce(Return());
93 EXPECT_CALL(*printServiceAbility.InitPreferenceMap(), _).WillOnce(Return());
94 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
95 }
96
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenPrintSubscribeCommonEventSucceeds)97 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenPrintSubscribeCommonEventSucceeds)
98 {
99 PrintServiceAbility printServiceAbility;
100 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
101 printServiceAbility.g_publishState = true;
102 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish()).WillOnce(Return(true));
103 EXPECT_CALL(*printServiceAbility.printSystemData, Init()).WillOnce(Return());
104 EXPECT_CALL(*printServiceAbility.InitPreferenceMap(),).WillOnce(Return());
105 EXPECT_CALL(*printServiceAbility.helper, PrintSubscribeCommonEvent()).WillOnce(Return());
106 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
107 }
108
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenIppOverUsbManagerInitSucceeds)109 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenIppOverUsbManagerInitSucceeds)
110 {
111 PrintServiceAbility printServiceAbility;
112 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
113 printServiceAbility.g_publishState = true;
114 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish()).WillOnce(Return(true));
115 EXPECT_CALL(*printServiceAbility.printSystemData, Init()).WillOnce(Return());
116 EXPECT_CALL(*printServiceAbility.InitPreferenceMap(),).WillOnce(Return());
117 EXPECT_CALL(*printServiceAbility.helper, PrintSubscribeCommonEvent()).WillOnce(Return());
118 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
119 }
120
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenCupsClientInitSucceeds)121 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenCupsClientInitSucceeds)
122 {
123 PrintServiceAbility printServiceAbility;
124 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
125 printServiceAbility.g_publishState = true;
126 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish()).WillOnce(Return(true));
127 EXPECT_CALL(*printServiceAbility.printSystemData, Init()).WillOnce(Return());
128 EXPECT_CALL(*printServiceAbility.InitPreferenceMap(),).WillOnce(Return());
129 EXPECT_CALL(*printServiceAbility.helper, PrintSubscribeCommonEvent()).WillOnce(Return());
130 EXPECT_CALL(*printServiceAbility.DelayedSingleton<PrintCupsClient>::GetInstance(),
131 InitCupsResources()).WillOnce(Return(ERR_OK));
132 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
133 }
134
TEST_F(nullTest,Init_ShouldReturnSuccess_WhenAllOperationsSucceed)135 TEST_F(nullTest, Init_ShouldReturnSuccess_WhenAllOperationsSucceed)
136 {
137 PrintServiceAbility printServiceAbility;
138 printServiceAbility.helper_ = std::make_shared<PrintServiceHelper>();
139 printServiceAbility.g_publishState = true;
140 EXPECT_CALL(*printServiceAbility.GetInstance(), Publish()).WillOnce(Return(true));
141 EXPECT_CALL(*printServiceAbility.printSystemData, Init()).WillOnce(Return());
142 EXPECT_CALL(*printServiceAbility.InitPreferenceMap(),).WillOnce(Return());
143 EXPECT_CALL(*printServiceAbility.helper, PrintSubscribeCommonEvent()).WillOnce(Return());
144 EXPECT_CALL(*printServiceAbility.DelayedSingleton<PrintCupsClient>::GetInstance(),
145 InitCupsResources()).WillOnce(Return(ERR_OK));
146 EXPECT_EQ(printServiceAbility.Init(), ERR_OK);
147 }
148
149 class PrintServiceAbilityTest : public nullTest {
150 public:
151 PrintServiceAbility* printServiceAbility;
SetUp()152 void SetUp() override
153 {
154 printServiceAbility = new PrintServiceAbility();
155 }
TearDown()156 void TearDown() override
157 {
158 delete printServiceAbility;
159 printServiceAbility = nullptr
160 }
161 };
162 HWTEST_F(PrintServiceAbilityTest, OnStart_ShouldSetInstance_WhenInstanceIsNull, TestSize.Level0)
163 {
164 printServiceAbility->instance_ = nullptr;
165 printServiceAbility->OnStart();
166 EXPECT_NE(printServiceAbility->instance_, nullptr);
167 }
168 HWTEST_F(PrintServiceAbilityTest, OnStart_ShouldSetStateRunning_WhenStateIsRunning, TestSize.Level0)
169 {
170 printServiceAbility->state_ = ServiceRunningState::STATE_RUNNING;
171 printServiceAbility->OnStart();
172 EXPECT_EQ(printServiceAbility->state_, ServiceRunningState::STATE_RUNNING);
173 }
174 HWTEST_F(PrintServiceAbilityTest, OnStart_ShouldInitServiceHandler_WhenStateIsNotRunning, TestSize.Level0)
175 {
176 printServiceAbility->state_ = ServiceRunningState::STATE_NOT_RUNNING;
177 printServiceAbility->OnStart();
178 EXPECT_NE(printServiceAbility->serviceHandler_, nullptr);
179 }
180 HWTEST_F(PrintServiceAbilityTest, OnStart_ShouldInitVendorManager_WhenStateIsNotRunning, TestSize.Level0)
181 {
182 printServiceAbility->state_ = ServiceRunningState::STATE_NOT_RUNNING;
183 printServiceAbility->OnStart();
184 EXPECT_NE(printServiceAbility->vendorManager, nullptr);
185 }
186 HWTEST_F(PrintServiceAbilityTest, OnStart_ShouldSetStateRunning_WhenInitReturnsOk, TestSize.Level0)
187 {
188 printServiceAbility->state_ = ServiceRunningState::STATE_NOT_RUNNING;
189 printServiceAbility->Init = undefined { return ERR_OK; };
190 printServiceAbility->OnStart();
191 EXPECT_EQ(printServiceAbility->state_, ServiceRunningState::STATE_RUNNING);
192 }
193 HWTEST_F(PrintServiceAbilityTest, OnStart_ShouldPostTask_WhenInitReturnsNotOk, TestSize.Level0)
194 {
195 printServiceAbility->state_ = ServiceRunningState::STATE_NOT_RUNNING;
196 printServiceAbility->Init = undefined { return ERR_UNKNOWN; };
197 printServiceAbility->serviceHandler_->PostTask = [](auto callback, auto interval)
__anon6a3cc7ef0102(auto callback, auto interval) 198 {
199 callback();
200 };
201 printServiceAbility->OnStart();
202 EXPECT_EQ(printServiceAbility->state_, ServiceRunningState::STATE_NOT_RUNNING);
203 }
204
TEST_F(nullTest,InitServiceHandler_Should_Return_When_ServiceHandler_Is_Null)205 TEST_F(nullTest, InitServiceHandler_Should_Return_When_ServiceHandler_Is_Null)
206 {
207 PrintServiceAbility printServiceAbility;
208 printServiceAbility.InitServiceHandler();
209 EXPECT_NE(printServiceAbility.serviceHandler_, nullptr);
210 }
211
TEST_F(nullTest,InitServiceHandler_Should_Not_Return_When_ServiceHandler_Is_Not_Null)212 TEST_F(nullTest, InitServiceHandler_Should_Not_Return_When_ServiceHandler_Is_Not_Null)
213 {
214 PrintServiceAbility printServiceAbility;
215 printServiceAbility.serviceHandler_ = std::make_shared AppExecFwk::EventHandlerundefined(
216 AppExecFwk::EventRunner::Create("PrintServiceAbility"));
217 printServiceAbility.InitServiceHandler();
218 EXPECT_EQ(printServiceAbility.serviceHandler_, nullptr);
219 }
220
221 class PrintServiceAbilityTest : public nullTest {
222 public:
223 PrintServiceAbility* printServiceAbility;
SetUp()224 void SetUp() override
225 {
226 printServiceAbility = new PrintServiceAbility();
227 }
TearDown()228 void TearDown() override
229 {
230 delete printServiceAbility;
231 printServiceAbility = nullptr
232 }
233 };
TEST_F(PrintServiceAbilityTest,ManualStart_ShouldRestart_WhenStateIsNotRunning)234 TEST_F(PrintServiceAbilityTest, ManualStart_ShouldRestart_WhenStateIsNotRunning)
235 {
236 printServiceAbility->state_ = ServiceRunningState::STATE_NOT_RUNNING;
237 printServiceAbility->ManualStart();
238 EXPECT_EQ(printServiceAbility->state_, ServiceRunningState::STATE_RUNNING);
239 }
240
TEST_F(PrintServiceAbilityTest,ManualStart_ShouldInitCupsResources_WhenStateIsRunningAndCupsIsEnabled)241 TEST_F(PrintServiceAbilityTest, ManualStart_ShouldInitCupsResources_WhenStateIsRunningAndCupsIsEnabled)
242 {
243 printServiceAbility->state_ = ServiceRunningState::STATE_RUNNING;
244 printServiceAbility->ManualStart();
245 EXPECT_EQ(printServiceAbility->state_, ServiceRunningState::STATE_RUNNING);
246 }
247
TEST_F(PrintServiceAbilityTest,ManualStart_ShouldNotInitCupsResources_WhenStateIsRunningAndCupsIsDisabled)248 TEST_F(PrintServiceAbilityTest, ManualStart_ShouldNotInitCupsResources_WhenStateIsRunningAndCupsIsDisabled)
249 {
250 printServiceAbility->state_ = ServiceRunningState::STATE_RUNNING;
251 printServiceAbility->ManualStart();
252 EXPECT_EQ(printServiceAbility->state_, ServiceRunningState::STATE_RUNNING);
253 }
254
255 class PrintServiceAbilityTest : public nullTest {
256 public:
257 PrintServiceAbility* printServiceAbility;
258 std::mutex instanceLock_;
259 int currentJobOrderId_ = 0;
SetUp()260 void SetUp() override
261 {
262 printServiceAbility = new PrintServiceAbility();
263 }
TearDown()264 void TearDown() override
265 {
266 delete printServiceAbility;
267 printServiceAbility = nullptr
268 }
269 };
270 HWTEST_F(PrintServiceAbilityTest, GetPrintJobOrderId_ShouldReturnIncrementingOrderId, TestSize.Level0)
271 {
272 std::string expectedOrderId = "1";
273 std::string actualOrderId = printServiceAbility->GetPrintJobOrderId();
274 EXPECT_EQ(expectedOrderId, actualOrderId);
275 }
276 HWTEST_F(PrintServiceAbilityTest,
277 GetPrintJobOrderId_ShouldReturnIncrementingOrderId_WhenCalledMultipleTimes, TestSize.Level0)
278 {
279 std::string expectedOrderId1 = "1";
280 std::string expectedOrderId2 = "2";
281 std::string actualOrderId1 = printServiceAbility->GetPrintJobOrderId();
282 std::string actualOrderId2 = printServiceAbility->GetPrintJobOrderId();
283 EXPECT_EQ(expectedOrderId1, actualOrderId1);
284 EXPECT_EQ(expectedOrderId2, actualOrderId2);
285 }
286 HWTEST_F(PrintServiceAbilityTest,
287 GetPrintJobOrderId_ShouldReturnIncrementingOrderId_WhenCalledConcurrently, TestSize.Level0)
288 {
289 std::string expectedOrderId1 = "1";
290 std::string expectedOrderId2 = "2";
291 std::thread thread1([&]()
__anon6a3cc7ef0202() 292 {
293 std::string actualOrderId1 = printServiceAbility->GetPrintJobOrderId();
294 EXPECT_EQ(expectedOrderId1, actualOrderId1);
295 });
296 std::thread thread2([&]()
__anon6a3cc7ef0302() 297 {
298 std::string actualOrderId2 = printServiceAbility->GetPrintJobOrderId();
299 EXPECT_EQ(expectedOrderId2, actualOrderId2);
300 });
301 thread1.join();
302 thread2.join();
303 }
304
305 class PrintServiceAbilityTest : public nullTest {
306 public:
SetUp()307 void SetUp() override
308 {
309 printServiceAbility = new PrintServiceAbility();
310 }
TearDown()311 void TearDown() override
312 {
313 delete printServiceAbility;
314 printServiceAbility = nullptr
315 }
316 PrintServiceAbility* printServiceAbility;
317 };
318 HWTEST_F(PrintServiceAbilityTest, OnStop_Should_Call_UnInit_When_State_Is_Running, TestSize.Level0)
319 {
320 printServiceAbility->state_ = ServiceRunningState::STATE_RUNNING;
321 EXPECT_CALL(printServiceAbility->vendorManager, UnInit()).Times(1);
322 printServiceAbility->OnStop();
323 }
324 HWTEST_F(PrintServiceAbilityTest, OnStop_Should_Not_Call_UnInit_When_State_Is_Not_Running, TestSize.Level0)
325 {
326 printServiceAbility->state_ = ServiceRunningState::STATE_NOT_START;
327 EXPECT_CALL(printServiceAbility->vendorManager, UnInit()).Times(0);
328 printServiceAbility->OnStop();
329 }
330 HWTEST_F(PrintServiceAbilityTest, OnStop_Should_Set_State_To_Not_Start_After_Call, TestSize.Level0)
331 {
332 printServiceAbility->state_ = ServiceRunningState::STATE_RUNNING;
333 printServiceAbility->OnStop();
334 EXPECT_EQ(printServiceAbility->state_, ServiceRunningState::STATE_NOT_START);
335 }
336
TEST_F(nullTest,StartService_ShouldReturnPermissionError_WhenNoPermission)337 TEST_F(nullTest, StartService_ShouldReturnPermissionError_WhenNoPermission)
338 {
339 PrintServiceAbility printService;
340 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(false));
341 EXPECT_EQ(printService.StartService(), E_PRINT_NO_PERMISSION);
342 }
343
TEST_F(nullTest,StartService_ShouldReturnNoError_WhenPermissionGranted)344 TEST_F(nullTest, StartService_ShouldReturnNoError_WhenPermissionGranted)
345 {
346 PrintServiceAbility printService;
347 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
348 EXPECT_EQ(printService.StartService(), E_PRINT_NONE);
349 }
350
TEST_F(nullTest,StartService_ShouldReturnNoError_WhenCUPSIsDisabled)351 TEST_F(nullTest, StartService_ShouldReturnNoError_WhenCUPSIsDisabled)
352 {
353 PrintServiceAbility printService;
354 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
355 #undef CUPS_ENABLE
356 EXPECT_EQ(printService.StartService(), E_PRINT_NONE);
357 }
358
TEST_F(nullTest,StartService_ShouldReturnNoError_WhenCUPSIsEnabled)359 TEST_F(nullTest, StartService_ShouldReturnNoError_WhenCUPSIsEnabled)
360 {
361 PrintServiceAbility printService;
362 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
363 #define CUPS_ENABLE
364 EXPECT_CALL(printService,
365 DelayedSingleton<PrintCupsClient>::GetInstance()->InitCupsResources()).WillOnce(Return(E_PRINT_NONE));
366 EXPECT_EQ(printService.StartService(), E_PRINT_NONE);
367 }
368
TEST_F(nullTest,CallSpooler_ShouldReturnPermissionError_WhenNoPermission)369 TEST_F(nullTest, CallSpooler_ShouldReturnPermissionError_WhenNoPermission)
370 {
371 std::vector std::stringundefined fileList;
372 std::vector<uint32_t> fdList;
373 std::string taskId;
374 PrintServiceAbility printServiceAbility;
375 int32_t result = printServiceAbility.CallSpooler(fileList, fdList, taskId);
376 EXPECT_EQ(result, E_PRINT_NO_PERMISSION);
377 }
378
TEST_F(nullTest,CallSpooler_ShouldReturnInvalidParameterError_WhenTaskIdIsEmpty)379 TEST_F(nullTest, CallSpooler_ShouldReturnInvalidParameterError_WhenTaskIdIsEmpty)
380 {
381 std::vector std::stringundefined fileList;
382 std::vector<uint32_t> fdList;
383 std::string taskId;
384 PrintServiceAbility printServiceAbility;
385 int32_t result = printServiceAbility.CallSpooler(fileList, fdList, taskId);
386 EXPECT_EQ(result, E_PRINT_INVALID_PARAMETER);
387 }
388
TEST_F(nullTest,CallSpooler_ShouldReturnServerFailureError_WhenPrintJobIsNull)389 TEST_F(nullTest, CallSpooler_ShouldReturnServerFailureError_WhenPrintJobIsNull)
390 {
391 std::vector std::stringundefined fileList;
392 std::vector<uint32_t> fdList;
393 std::string taskId = "testTaskId";
394 PrintServiceAbility printServiceAbility;
395 int32_t result = printServiceAbility.CallSpooler(fileList, fdList, taskId);
396 EXPECT_EQ(result, E_PRINT_SERVER_FAILURE);
397 }
398
TEST_F(nullTest,CallSpooler_ShouldReturnNoneError_WhenAllParametersAreValid)399 TEST_F(nullTest, CallSpooler_ShouldReturnNoneError_WhenAllParametersAreValid)
400 {
401 std::vector std::stringundefined fileList;
402 std::vector<uint32_t> fdList;
403 std::string taskId = "testTaskId";
404 PrintServiceAbility printServiceAbility;
405 int32_t result = printServiceAbility.CallSpooler(fileList, fdList, taskId);
406 EXPECT_EQ(result, E_PRINT_NONE);
407 }
408
409 class PrintServiceAbilityTest : public nullTest {
410 public:
411 PrintServiceAbility* printServiceAbility;
SetUp()412 void SetUp() override
413 {
414 printServiceAbility = new PrintServiceAbility();
415 }
TearDown()416 void TearDown() override
417 {
418 delete printServiceAbility;
419 printServiceAbility = nullptr
420 }
421 };
422 12345
423 HWTEST_F(PrintServiceAbilityTest,
424 StopPrint_ShouldReturnNoPermission_WhenNoPermission, TestSize.Level0)
425 {
426 std::string taskId = "testTaskId";
__anon6a3cc7ef0402(const std::string& permission) 427 printServiceAbility->CheckPermission = [](const std::string& permission) { return false; };
428 int32_t result = printServiceAbility->StopPrint(taskId);
429 EXPECT_EQ(result, E_PRINT_NO_PERMISSION);
430 }
431 HWTEST_F(PrintServiceAbilityTest, StopPrint_ShouldReturnNone_WhenPermissionGranted, TestSize.Level0)
432 {
433 std::string taskId = "testTaskId";
__anon6a3cc7ef0502(const std::string& permission) 434 printServiceAbility->CheckPermission = [](const std::string& permission) { return true; };
435 int32_t result = printServiceAbility->StopPrint(taskId);
436 EXPECT_EQ(result, E_PRINT_NONE);
437 }
438
439 class PrintServiceAbilityTest : public nullTest {
440 public:
441 PrintServiceAbility* printServiceAbility;
SetUp()442 void SetUp() override
443 {
444 printServiceAbility = new PrintServiceAbility();
445 }
TearDown()446 void TearDown() override
447 {
448 delete printServiceAbility;
449 printServiceAbility = nullptr
450 }
451 };
452 HWTEST_F(PrintServiceAbilityTest,
453 HandleExtensionConnectPrinter_ShouldReturnFailure_WhenPrinterIdIsEmpty, TestSize.Level0)
454 {
455 std::string printerId = "";
456 int32_t result = printServiceAbility->HandleExtensionConnectPrinter(printerId);
457 EXPECT_EQ(result, E_PRINT_SERVER_FAILURE);
458 }
459 HWTEST_F(PrintServiceAbilityTest,
460 HandleExtensionConnectPrinter_ShouldReturnNone_WhenPrinterIdIsNotEmpty, TestSize.Level0)
461 {
462 std::string printerId = "validPrinterId";
463 int32_t result = printServiceAbility->HandleExtensionConnectPrinter(printerId);
464 EXPECT_EQ(result, E_PRINT_NONE);
465 }
466 HWTEST_F(PrintServiceAbilityTest,
467 HandleExtensionConnectPrinter_ShouldReturnFailure_WhenExtensionNotRegistered, TestSize.Level0)
468 {
469 std::string printerId = "validPrinterId";
470 int32_t result = printServiceAbility->HandleExtensionConnectPrinter(printerId);
471 EXPECT_EQ(result, E_PRINT_SERVER_FAILURE);
472 }
473 HWTEST_F(PrintServiceAbilityTest,
474 HandleExtensionConnectPrinter_ShouldReturnNone_WhenExtensionRegistered, TestSize.Level0)
475 {
476 std::string printerId = "validPrinterId";
477 int32_t result = printServiceAbility->HandleExtensionConnectPrinter(printerId);
478 EXPECT_EQ(result, E_PRINT_NONE);
479 }
480 HWTEST_F(PrintServiceAbilityTest,
481 HandleExtensionConnectPrinter_ShouldReturnNone_WhenPrinterIdIsValidAndExtensionRegistered, TestSize.Level0)
482 {
483 std::string printerId = "validPrinterId";
484 int32_t result = printServiceAbility->HandleExtensionConnectPrinter(printerId);
485 EXPECT_EQ(result, E_PRINT_NONE);
486 }
487
TEST_F(nullTest,ConnectPrinter_ShouldReturnNoPermission_WhenNoPermission)488 TEST_F(nullTest, ConnectPrinter_ShouldReturnNoPermission_WhenNoPermission)
489 {
490 PrintServiceAbility printServiceAbility;
491 std::string printerId = "testPrinter";
492 EXPECT_EQ(printServiceAbility.ConnectPrinter(printerId), E_PRINT_NO_PERMISSION);
493 }
494
TEST_F(nullTest,ConnectPrinter_ShouldReturnServerFailure_WhenVendorNotFound)495 TEST_F(nullTest, ConnectPrinter_ShouldReturnServerFailure_WhenVendorNotFound)
496 {
497 PrintServiceAbility printServiceAbility;
498 std::string printerId = "testPrinter";
499 EXPECT_EQ(printServiceAbility.ConnectPrinter(printerId), E_PRINT_SERVER_FAILURE);
500 }
501
TEST_F(nullTest,ConnectPrinter_ShouldReturnNone_WhenConnectPrinterSucceed)502 TEST_F(nullTest, ConnectPrinter_ShouldReturnNone_WhenConnectPrinterSucceed)
503 {
504 PrintServiceAbility printServiceAbility;
505 std::string printerId = "testPrinter";
506 EXPECT_EQ(printServiceAbility.ConnectPrinter(printerId), E_PRINT_NONE);
507 }
508
TEST_F(nullTest,ConnectPrinter_ShouldReturnInvalidPrinterId_WhenPrinterIdIsInvalid)509 TEST_F(nullTest, ConnectPrinter_ShouldReturnInvalidPrinterId_WhenPrinterIdIsInvalid)
510 {
511 PrintServiceAbility printServiceAbility;
512 std::string printerId = "invalidPrinter";
513 EXPECT_EQ(printServiceAbility.ConnectPrinter(printerId), E_PRINT_INVALID_PRINTER_ID);
514 }
515
TEST_F(nullTest,DisconnectPrinter_ShouldReturnNoPermission_WhenNoPermission)516 TEST_F(nullTest, DisconnectPrinter_ShouldReturnNoPermission_WhenNoPermission)
517 {
518 PrintServiceAbility printServiceAbility;
519 std::string printerId = "testPrinter";
520 EXPECT_EQ(printServiceAbility.DisconnectPrinter(printerId), E_PRINT_NO_PERMISSION);
521 }
522
TEST_F(nullTest,DisconnectPrinter_ShouldReturnInvalidPrinter_WhenInvalidPrinterId)523 TEST_F(nullTest, DisconnectPrinter_ShouldReturnInvalidPrinter_WhenInvalidPrinterId)
524 {
525 PrintServiceAbility printServiceAbility;
526 std::string printerId = "invalidPrinter";
527 EXPECT_EQ(printServiceAbility.DisconnectPrinter(printerId), E_PRINT_INVALID_PRINTER);
528 }
529
TEST_F(nullTest,DisconnectPrinter_ShouldReturnServerFailure_WhenNotRegisterYet)530 TEST_F(nullTest, DisconnectPrinter_ShouldReturnServerFailure_WhenNotRegisterYet)
531 {
532 PrintServiceAbility printServiceAbility;
533 std::string printerId = "newPrinter";
534 EXPECT_EQ(printServiceAbility.DisconnectPrinter(printerId), E_PRINT_SERVER_FAILURE);
535 }
536
TEST_F(nullTest,DisconnectPrinter_ShouldReturnNone_WhenSuccess)537 TEST_F(nullTest, DisconnectPrinter_ShouldReturnNone_WhenSuccess)
538 {
539 PrintServiceAbility printServiceAbility;
540 std::string printerId = "validPrinter";
541 EXPECT_EQ(printServiceAbility.DisconnectPrinter(printerId), E_PRINT_NONE);
542 }
543
TEST_F(nullTest,StartDiscoverPrinter_ShouldReturnNoPermission_WhenPermissionIsFalse)544 TEST_F(nullTest, StartDiscoverPrinter_ShouldReturnNoPermission_WhenPermissionIsFalse)
545 {
546 PrintServiceAbility printServiceAbility;
547 std::vector std::stringundefined extensionIds = {"ext1", "ext2"};
548 EXPECT_EQ(printServiceAbility.StartDiscoverPrinter(extensionIds), E_PRINT_NO_PERMISSION);
549 }
550
TEST_F(nullTest,StartDiscoverPrinter_ShouldReturnSuccess_WhenPermissionIsTrue)551 TEST_F(nullTest, StartDiscoverPrinter_ShouldReturnSuccess_WhenPermissionIsTrue)
552 {
553 PrintServiceAbility printServiceAbility;
554 std::vector std::stringundefined extensionIds = {"ext1", "ext2"};
555 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
556 EXPECT_EQ(printServiceAbility.StartDiscoverPrinter(extensionIds), 0);
557 }
558
TEST_F(nullTest,StartDiscoverPrinter_ShouldReturnSuccess_WhenManualStartSucceeds)559 TEST_F(nullTest, StartDiscoverPrinter_ShouldReturnSuccess_WhenManualStartSucceeds)
560 {
561 PrintServiceAbility printServiceAbility;
562 std::vector std::stringundefined extensionIds = {"ext1", "ext2"};
563 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
564 printServiceAbility.ManualStart = undefined {};
565 EXPECT_EQ(printServiceAbility.StartDiscoverPrinter(extensionIds), 0);
566 }
567
TEST_F(nullTest,StartDiscoverPrinter_ShouldReturnSuccess_WhenAllMethodsSucceed)568 TEST_F(nullTest, StartDiscoverPrinter_ShouldReturnSuccess_WhenAllMethodsSucceed)
569 {
570 PrintServiceAbility printServiceAbility;
571 std::vector std::stringundefined extensionIds = {"ext1", "ext2"};
572 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
573 printServiceAbility.ManualStart = undefined {};
574 printServiceAbility.printSystemData_.QueryAddedPrinterIdList = undefined { return std::vector; };
575 printServiceAbility.vendorManager.MonitorPrinterStatus = [](const std::string& printerId, bool start) {};
576 printServiceAbility.vendorManager.StartStatusMonitor = undefined {};
577 printServiceAbility.vendorManager.StartDiscovery = undefined {};
578 printServiceAbility.StartExtensionDiscovery = [](const std::vector std::stringundefined& extensionIds) { return 0; };
579 EXPECT_EQ(printServiceAbility.StartDiscoverPrinter(extensionIds), 0);
580 }
581
TEST_F(nullTest,DelayStartDiscovery_ShouldReturnFalse_WhenExtensionIdNotFound)582 TEST_F(nullTest, DelayStartDiscovery_ShouldReturnFalse_WhenExtensionIdNotFound)
583 {
584 PrintServiceAbility printServiceAbility;
585 std::string extensionId = "nonexistent";
586 EXPECT_EQ(printServiceAbility.DelayStartDiscovery(extensionId), false);
587 }
588
TEST_F(nullTest,DelayStartDiscovery_ShouldReturnFalse_WhenExtensionStateIsNotLoaded)589 TEST_F(nullTest, DelayStartDiscovery_ShouldReturnFalse_WhenExtensionStateIsNotLoaded)
590 {
591 PrintServiceAbility printServiceAbility;
592 std::string extensionId = "existent";
593 printServiceAbility.extensionStateList_[extensionId] = PRINT_EXTENSION_NOT_LOADED;
594 EXPECT_EQ(printServiceAbility.DelayStartDiscovery(extensionId), false);
595 }
596
TEST_F(nullTest,DelayStartDiscovery_ShouldReturnFalse_WhenCallbackNotRegistered)597 TEST_F(nullTest, DelayStartDiscovery_ShouldReturnFalse_WhenCallbackNotRegistered)
598 {
599 PrintServiceAbility printServiceAbility;
600 std::string extensionId = "existent";
601 printServiceAbility.extensionStateList_[extensionId] = PRINT_EXTENSION_LOADED;
602 EXPECT_EQ(printServiceAbility.DelayStartDiscovery(extensionId), false);
603 }
604
TEST_F(nullTest,DelayStartDiscovery_ShouldReturnTrue_WhenCallbackRegisteredAndOnCallbackReturnsTrue)605 TEST_F(nullTest, DelayStartDiscovery_ShouldReturnTrue_WhenCallbackRegisteredAndOnCallbackReturnsTrue)
606 {
607 PrintServiceAbility printServiceAbility;
608 std::string extensionId = "existent";
609 printServiceAbility.extensionStateList_[extensionId] = PRINT_EXTENSION_LOADED;
610 std::string cid = PrintUtils::EncodeExtensionCid(extensionId, PRINT_EXTCB_START_DISCOVERY);
611 printServiceAbility.extCallbackMap_[cid] = new Callback();
612 EXPECT_CALL(*printServiceAbility.extCallbackMap_[cid], OnCallback()).WillOnce(Return(true));
613 EXPECT_EQ(printServiceAbility.DelayStartDiscovery(extensionId), true);
614 }
615
TEST_F(nullTest,DelayStartDiscovery_ShouldReturnFalse_WhenCallbackRegisteredAndOnCallbackReturnsFalse)616 TEST_F(nullTest, DelayStartDiscovery_ShouldReturnFalse_WhenCallbackRegisteredAndOnCallbackReturnsFalse)
617 {
618 PrintServiceAbility printServiceAbility;
619 std::string extensionId = "existent";
620 printServiceAbility.extensionStateList_[extensionId] = PRINT_EXTENSION_LOADED;
621 std::string cid = PrintUtils::EncodeExtensionCid(extensionId, PRINT_EXTCB_START_DISCOVERY);
622 printServiceAbility.extCallbackMap_[cid] = new Callback();
623 EXPECT_CALL(*printServiceAbility.extCallbackMap_[cid], OnCallback()).WillOnce(Return(false));
624 EXPECT_EQ(printServiceAbility.DelayStartDiscovery(extensionId), false);
625 }
626
627 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnNoPermission_WhenNoPermission, TestSize.Level0)
628 {
629 PrintServiceAbility printService;
630 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(false));
631 int32_t result = printService.StopDiscoverPrinter();
632 EXPECT_EQ(result, E_PRINT_NO_PERMISSION);
633 }
634
635 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnNone_WhenStoppedSuccessfully, TestSize.Level0)
636 {
637 PrintServiceAbility printService;
638 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
639 int32_t result = printService.StopDiscoverPrinter();
640 EXPECT_EQ(result, E_PRINT_NONE);
641 }
642
643 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnFailure_WhenStopDiscoveryFails, TestSize.Level0)
644 {
645 PrintServiceAbility printService;
646 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
647 EXPECT_CALL(printService, vendorManager.StopDiscovery()).WillOnce(Return(false));
648 int32_t result = printService.StopDiscoverPrinter();
649 EXPECT_NE(result, E_PRINT_NONE);
650 }
651
652 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnFailure_WhenStopStatusMonitorFails, TestSize.Level0)
653 {
654 PrintServiceAbility printService;
655 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
656 EXPECT_CALL(printService, vendorManager.StopStatusMonitor()).WillOnce(Return(false));
657 int32_t result = printService.StopDiscoverPrinter();
658 EXPECT_NE(result, E_PRINT_NONE);
659 }
660
661 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnFailure_WhenExtensionNotLoaded, TestSize.Level0)
662 {
663 PrintServiceAbility printService;
664 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
665 EXPECT_CALL(printService, extensionStateList_.second < PRINT_EXTENSION_LOADING).WillOnce(Return(true));
666 int32_t result = printService.StopDiscoverPrinter();
667 EXPECT_NE(result, E_PRINT_NONE);
668 }
669
670 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnFailure_WhenExtensionCallbackNotRegistered, TestSize.Level0)
671 {
672 PrintServiceAbility printService;
673 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
674 EXPECT_CALL(printService, extensionStateList_.second >= PRINT_EXTENSION_LOADING).WillOnce(Return(true));
675 EXPECT_CALL(printService, extCallbackMap_.find(PrintUtils::EncodeExtensionCid(extension.first,
676 PRINT_EXTCB_STOP_DISCOVERY))).WillOnce(Return(extCallbackMap_.end()));
677 int32_t result = printService.StopDiscoverPrinter();
678 EXPECT_NE(result, E_PRINT_NONE);
679 }
680
681 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnNone_WhenStoppedSuccessfully, TestSize.Level0)
682 {
683 PrintServiceAbility printService;
684 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
685 EXPECT_CALL(printService, extensionStateList_.second >= PRINT_EXTENSION_LOADING).WillOnce(Return(true));
686 EXPECT_CALL(printService, extCallbackMap_.find(PrintUtils::EncodeExtensionCid(extension.first,
687 PRINT_EXTCB_STOP_DISCOVERY))).WillOnce(Return(extCallbackMap_.begin()));
688 EXPECT_CALL(printService, helper_->IsSyncMode()).WillOnce(Return(true));
689 int32_t result = printService.StopDiscoverPrinter();
690 EXPECT_EQ(result, E_PRINT_NONE);
691 }
692
693 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnNone_WhenHelperNotSyncMode, TestSize.Level0)
694 {
695 PrintServiceAbility printService;
696 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
697 EXPECT_CALL(printService, extensionStateList_.second >= PRINT_EXTENSION_LOADING).WillOnce(Return(true));
698 EXPECT_CALL(printService, extCallbackMap_.find(PrintUtils::EncodeExtensionCid(extension.first,
699 PRINT_EXTCB_STOP_DISCOVERY))).WillOnce(Return(extCallbackMap_.begin()));
700 EXPECT_CALL(printService, helper_->IsSyncMode()).WillOnce(Return(false));
701 int32_t result = printService.StopDiscoverPrinter();
702 EXPECT_EQ(result, E_PRINT_NONE);
703 }
704
705 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnFailure_WhenPostTaskFails, TestSize.Level0)
706 {
707 PrintServiceAbility printService;
708 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
709 EXPECT_CALL(printService, extensionStateList_.second >= PRINT_EXTENSION_LOADING).WillOnce(Return(true));
710 EXPECT_CALL(printService, extCallbackMap_.find(PrintUtils::EncodeExtensionCid(extension.first,
711 PRINT_EXTCB_STOP_DISCOVERY))).WillOnce(Return(extCallbackMap_.begin()));
712 EXPECT_CALL(printService, helper_->IsSyncMode()).WillOnce(Return(false));
713 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(false));
714 int32_t result = printService.StopDiscoverPrinter();
715 EXPECT_NE(result, E_PRINT_NONE);
716 }
717
718 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnNone_WhenStoppedSuccessfully, TestSize.Level0)
719 {
720 PrintServiceAbility printService;
721 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
722 EXPECT_CALL(printService, extensionStateList_.second >= PRINT_EXTENSION_LOADING).WillOnce(Return(true));
723 EXPECT_CALL(printService, extCallbackMap_.find(PrintUtils::EncodeExtensionCid(extension.first,
724 PRINT_EXTCB_STOP_DISCOVERY))).WillOnce(Return(extCallbackMap_.begin()));
725 EXPECT_CALL(printService, helper_->IsSyncMode()).WillOnce(Return(false));
726 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(true));
727 int32_t result = printService.StopDiscoverPrinter();
728 EXPECT_EQ(result, E_PRINT_NONE);
729 }
730
731 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnFailure_WhenPostTaskCallbackFails, TestSize.Level0)
732 {
733 PrintServiceAbility printService;
734 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
735 EXPECT_CALL(printService, extensionStateList_.second >= PRINT_EXTENSION_LOADING).WillOnce(Return(true));
736 EXPECT_CALL(printService, extCallbackMap_.find(PrintUtils::EncodeExtensionCid(extension.first,
737 PRINT_EXTCB_STOP_DISCOVERY))).WillOnce(Return(extCallbackMap_.begin()));
738 EXPECT_CALL(printService, helper_->IsSyncMode()).WillOnce(Return(false));
739 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(true));
740 EXPECT_CALL(printService, cbFunc->OnCallback()).WillOnce(Return(false));
741 int32_t result = printService.StopDiscoverPrinter();
742 EXPECT_NE(result, E_PRINT_NONE);
743 }
744
745 HWTEST_F(nullTest, StopDiscoverPrinter_ShouldReturnNone_WhenStoppedSuccessfully, TestSize.Level0)
746 {
747 PrintServiceAbility printService;
748 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
749 EXPECT_CALL(printService, extensionStateList_.second >= PRINT_EXTENSION_LOADING).WillOnce(Return(true));
750 EXPECT_CALL(printService, extCallbackMap_.find(
751 PrintUtils::EncodeExtensionCid(extension.first,
752 PRINT_EXTCB_STOP_DISCOVERY))).WillOnce(Return(extCallbackMap_.begin()));
753 EXPECT_CALL(printService, helper_->IsSyncMode()).WillOnce(Return(false));
754 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(true));
755 EXPECT_CALL(printService, cbFunc->OnCallback()).WillOnce(Return(true));
756 int32_t result = printService.StopDiscoverPrinter();
757 EXPECT_EQ(result, E_PRINT_NONE);
758 }
759
TEST_F(nullTest,DestroyExtension_ShouldReturnNoPermission_WhenPermissionIsFalse)760 TEST_F(nullTest, DestroyExtension_ShouldReturnNoPermission_WhenPermissionIsFalse)
761 {
762 PrintServiceAbility printServiceAbility;
763 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(false));
764 EXPECT_EQ(printServiceAbility.DestroyExtension(), E_PRINT_NO_PERMISSION);
765 }
766
TEST_F(nullTest,DestroyExtension_ShouldReturnNone_WhenPermissionIsTrue)767 TEST_F(nullTest, DestroyExtension_ShouldReturnNone_WhenPermissionIsTrue)
768 {
769 PrintServiceAbility printServiceAbility;
770 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
771 EXPECT_EQ(printServiceAbility.DestroyExtension(), E_PRINT_NONE);
772 }
773
TEST_F(nullTest,DestroyExtension_ShouldReturnNone_WhenExtensionStateIsLessThanLoading)774 TEST_F(nullTest, DestroyExtension_ShouldReturnNone_WhenExtensionStateIsLessThanLoading)
775 {
776 PrintServiceAbility printServiceAbility;
777 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
778 printServiceAbility.extensionStateList_.push_back(std::make_pair("test", PRINT_EXTENSION_UNLOAD));
779 EXPECT_EQ(printServiceAbility.DestroyExtension(), E_PRINT_NONE);
780 }
781
TEST_F(nullTest,DestroyExtension_ShouldReturnNone_WhenExtensionCallbackNotFound)782 TEST_F(nullTest, DestroyExtension_ShouldReturnNone_WhenExtensionCallbackNotFound)
783 {
784 PrintServiceAbility printServiceAbility;
785 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
786 printServiceAbility.extensionStateList_.push_back(std::make_pair("test", PRINT_EXTENSION_LOADING));
787 EXPECT_EQ(printServiceAbility.DestroyExtension(), E_PRINT_NONE);
788 }
789
TEST_F(nullTest,DestroyExtension_ShouldReturnNone_WhenExtensionCallbackFound)790 TEST_F(nullTest, DestroyExtension_ShouldReturnNone_WhenExtensionCallbackFound)
791 {
792 PrintServiceAbility printServiceAbility;
793 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
794 printServiceAbility.extensionStateList_.push_back(std::make_pair("test", PRINT_EXTENSION_LOADING));
795 printServiceAbility.extCallbackMap_["test"] = new Callback();
796 EXPECT_EQ(printServiceAbility.DestroyExtension(), E_PRINT_NONE);
797 }
798
TEST_F(nullTest,QueryAllExtension_ShouldReturnPermissionDenied_WhenNoPermission)799 TEST_F(nullTest, QueryAllExtension_ShouldReturnPermissionDenied_WhenNoPermission)
800 {
801 PrintServiceAbility printServiceAbility;
802 std::vector<PrintExtensionInfo> extensionInfos;
803 printServiceAbility.CheckPermission = [](const std::string& permission) { return false; };
804 int32_t result = printServiceAbility.QueryAllExtension(extensionInfos);
805 EXPECT_EQ(result, E_PRINT_NO_PERMISSION);
806 }
807
TEST_F(nullTest,QueryAllExtension_ShouldReturnServerFailure_WhenQueryExtensionFails)808 TEST_F(nullTest, QueryAllExtension_ShouldReturnServerFailure_WhenQueryExtensionFails)
809 {
810 PrintServiceAbility printServiceAbility;
811 std::vector<PrintExtensionInfo> extensionInfos;
812 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
813 printServiceAbility.DelayedSingleton<PrintBMSHelper>::GetInstance()->
814 QueryExtensionInfos = [](std::vector AppExecFwk::ExtensionAbilityInfoundefined& info) { return false; };
815 int32_t result = printServiceAbility.QueryAllExtension(extensionInfos);
816 EXPECT_EQ(result, E_PRINT_SERVER_FAILURE);
817 }
818
TEST_F(nullTest,QueryAllExtension_ShouldReturnNone_WhenQueryExtensionSucceeds)819 TEST_F(nullTest, QueryAllExtension_ShouldReturnNone_WhenQueryExtensionSucceeds)
820 {
821 PrintServiceAbility printServiceAbility;
822 std::vector<PrintExtensionInfo> extensionInfos;
823 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
824 printServiceAbility.DelayedSingleton<PrintBMSHelper>::GetInstance()->
825 QueryExtensionInfos = [](std::vector AppExecFwk::ExtensionAbilityInfoundefined& info) { return true; };
826 int32_t result = printServiceAbility.QueryAllExtension(extensionInfos);
827 EXPECT_EQ(result, E_PRINT_NONE);
828 }
829
TEST_F(nullTest,QueryAllPrintJob_ShouldReturnNoPermission_WhenPermissionIsFalse)830 TEST_F(nullTest, QueryAllPrintJob_ShouldReturnNoPermission_WhenPermissionIsFalse)
831 {
832 PrintServiceAbility printServiceAbility;
833 std::vector<PrintJob> printJobs;
834 EXPECT_EQ(printServiceAbility.QueryAllPrintJob(printJobs), E_PRINT_NO_PERMISSION);
835 }
836
TEST_F(nullTest,QueryAllPrintJob_ShouldReturnInvalidUserId_WhenUserDataIsNull)837 TEST_F(nullTest, QueryAllPrintJob_ShouldReturnInvalidUserId_WhenUserDataIsNull)
838 {
839 PrintServiceAbility printServiceAbility;
840 std::vector<PrintJob> printJobs;
841 printServiceAbility.ManualStart();
842 printServiceAbility.CheckPermission(PERMISSION_NAME_PRINT_JOB) = true;
843 EXPECT_EQ(printServiceAbility.QueryAllPrintJob(printJobs), E_PRINT_INVALID_USERID);
844 }
845
TEST_F(nullTest,QueryAllPrintJob_ShouldReturnQueryAllPrintJobFailed_WhenQueryAllPrintJobReturnsFailure)846 TEST_F(nullTest, QueryAllPrintJob_ShouldReturnQueryAllPrintJobFailed_WhenQueryAllPrintJobReturnsFailure)
847 {
848 PrintServiceAbility printServiceAbility;
849 std::vector<PrintJob> printJobs;
850 printServiceAbility.ManualStart();
851 printServiceAbility.CheckPermission(PERMISSION_NAME_PRINT_JOB) = true;
852 printServiceAbility.GetCurrentUserData() = std::make_shared<UserData>();
853 EXPECT_EQ(printServiceAbility.QueryAllPrintJob(printJobs), E_PRINT_QUERY_ALL_PRINT_JOB_FAILED);
854 }
855
TEST_F(nullTest,QueryAllPrintJob_ShouldReturnNone_WhenQueryAllPrintJobSucceeds)856 TEST_F(nullTest, QueryAllPrintJob_ShouldReturnNone_WhenQueryAllPrintJobSucceeds)
857 {
858 PrintServiceAbility printServiceAbility;
859 std::vector<PrintJob> printJobs;
860 printServiceAbility.ManualStart();
861 printServiceAbility.CheckPermission(PERMISSION_NAME_PRINT_JOB) = true;
862 printServiceAbility.GetCurrentUserData() = std::make_shared<UserData>();
863 printServiceAbility.QueryAllPrintJob(printJobs) = E_PRINT_NONE;
864 EXPECT_EQ(printServiceAbility.QueryAllPrintJob(printJobs), E_PRINT_NONE);
865 }
866
TEST_F(nullTest,QueryAddedPrinter_ShouldReturnNoPermission_WhenNoPermission)867 TEST_F(nullTest, QueryAddedPrinter_ShouldReturnNoPermission_WhenNoPermission)
868 {
869 std::vector std::stringundefined printerList;
870 EXPECT_EQ(PrintServiceAbility::QueryAddedPrinter(printerList), E_PRINT_NO_PERMISSION);
871 }
872
TEST_F(nullTest,QueryAddedPrinter_ShouldReturnNone_WhenNoAddedPrinter)873 TEST_F(nullTest, QueryAddedPrinter_ShouldReturnNone_WhenNoAddedPrinter)
874 {
875 std::vector std::stringundefined printerList;
876 EXPECT_EQ(PrintServiceAbility::QueryAddedPrinter(printerList), E_PRINT_NONE);
877 }
878
TEST_F(nullTest,QueryAddedPrinter_ShouldReturnNone_WhenAddedPrinterExists)879 TEST_F(nullTest, QueryAddedPrinter_ShouldReturnNone_WhenAddedPrinterExists)
880 {
881 std::vector std::stringundefined printerList;
882 EXPECT_EQ(PrintServiceAbility::QueryAddedPrinter(printerList), E_PRINT_NONE);
883 }
884
TEST_F(nullTest,QueryAddedPrinter_ShouldReturnNone_WhenAddedPrinterExistsAndQueried)885 TEST_F(nullTest, QueryAddedPrinter_ShouldReturnNone_WhenAddedPrinterExistsAndQueried)
886 {
887 std::vector std::stringundefined printerList;
888 EXPECT_EQ(PrintServiceAbility::QueryAddedPrinter(printerList), E_PRINT_NONE);
889 }
890
TEST_F(nullTest,QueryAddedPrinter_ShouldReturnNone_WhenAddedPrinterExistsButQueriedIdIsEmpty)891 TEST_F(nullTest, QueryAddedPrinter_ShouldReturnNone_WhenAddedPrinterExistsButQueriedIdIsEmpty)
892 {
893 std::vector std::stringundefined printerList;
894 EXPECT_EQ(PrintServiceAbility::QueryAddedPrinter(printerList), E_PRINT_NONE);
895 }
896
TEST_F(nullTest,QueryPrinterInfoByPrinterId_Test)897 TEST_F(nullTest, QueryPrinterInfoByPrinterId_Test)
898 {
899 PrintServiceAbility printServiceAbility;
900 PrinterInfo info;
901 std::string printerId = "testPrinter";
902 int32_t result = printServiceAbility.QueryPrinterInfoByPrinterId(printerId, info);
903 EXPECT_EQ(result, E_PRINT_NONE);
904 }
905
TEST_F(nullTest,QueryPrinterInfoByPrinterId_NoPermission_Test)906 TEST_F(nullTest, QueryPrinterInfoByPrinterId_NoPermission_Test)
907 {
908 PrintServiceAbility printServiceAbility;
909 PrinterInfo info;
910 std::string printerId = "testPrinter";
911 int32_t result = printServiceAbility.QueryPrinterInfoByPrinterId(printerId, info);
912 EXPECT_EQ(result, E_PRINT_NO_PERMISSION);
913 }
914
TEST_F(nullTest,QueryPrinterInfoByPrinterId_InvalidPrinter_Test)915 TEST_F(nullTest, QueryPrinterInfoByPrinterId_InvalidPrinter_Test)
916 {
917 PrintServiceAbility printServiceAbility;
918 PrinterInfo info;
919 std::string printerId = "invalidPrinter";
920 int32_t result = printServiceAbility.QueryPrinterInfoByPrinterId(printerId, info);
921 EXPECT_EQ(result, E_PRINT_INVALID_PRINTER);
922 }
923
TEST_F(nullTest,QueryPrinterInfoByPrinterId_DefaultPrinter_Test)924 TEST_F(nullTest, QueryPrinterInfoByPrinterId_DefaultPrinter_Test)
925 {
926 PrintServiceAbility printServiceAbility;
927 PrinterInfo info;
928 std::string printerId = "defaultPrinter";
929 int32_t result = printServiceAbility.QueryPrinterInfoByPrinterId(printerId, info);
930 EXPECT_EQ(result, E_PRINT_NONE);
931 EXPECT_TRUE(info.GetIsDefaultPrinter());
932 }
933
TEST_F(nullTest,QueryPrinterInfoByPrinterId_LastUsedPrinter_Test)934 TEST_F(nullTest, QueryPrinterInfoByPrinterId_LastUsedPrinter_Test)
935 {
936 PrintServiceAbility printServiceAbility;
937 PrinterInfo info;
938 std::string printerId = "lastUsedPrinter";
939 int32_t result = printServiceAbility.QueryPrinterInfoByPrinterId(printerId, info);
940 EXPECT_EQ(result, E_PRINT_NONE);
941 EXPECT_TRUE(info.GetIsLastUsedPrinter());
942 }
943
TEST_F(nullTest,QueryPrinterProperties_ShouldReturnNoPermission_WhenNoPermission)944 TEST_F(nullTest, QueryPrinterProperties_ShouldReturnNoPermission_WhenNoPermission)
945 {
946 std::string printerId = "testPrinter";
947 std::vector std::stringundefined keyList = {"printerPreference"};
948 std::vector std::stringundefined valueList;
949 EXPECT_EQ(PrintServiceAbility::QueryPrinterProperties(printerId, keyList, valueList), E_PRINT_NO_PERMISSION);
950 }
951
TEST_F(nullTest,QueryPrinterProperties_ShouldReturnInvalidPrinter_WhenPrinterInfoNotFound)952 TEST_F(nullTest, QueryPrinterProperties_ShouldReturnInvalidPrinter_WhenPrinterInfoNotFound)
953 {
954 std::string printerId = "nonExistentPrinter";
955 std::vector std::stringundefined keyList = {"printerPreference"};
956 std::vector std::stringundefined valueList;
957 EXPECT_EQ(PrintServiceAbility::QueryPrinterProperties(printerId, keyList, valueList), E_PRINT_INVALID_PRINTER);
958 }
959
TEST_F(nullTest,QueryPrinterProperties_ShouldReturnNone_WhenPrinterPreferenceFound)960 TEST_F(nullTest, QueryPrinterProperties_ShouldReturnNone_WhenPrinterPreferenceFound)
961 {
962 std::string printerId = "testPrinter";
963 std::vector std::stringundefined keyList = {"printerPreference"};
964 std::vector std::stringundefined valueList;
965 EXPECT_EQ(PrintServiceAbility::QueryPrinterProperties(printerId, keyList, valueList), E_PRINT_NONE);
966 }
967
TEST_F(nullTest,QueryPrinterProperties_ShouldReturnNone_WhenNoKeyFound)968 TEST_F(nullTest, QueryPrinterProperties_ShouldReturnNone_WhenNoKeyFound)
969 {
970 std::string printerId = "testPrinter";
971 std::vector std::stringundefined keyList = {"nonExistentKey"};
972 std::vector std::stringundefined valueList;
973 EXPECT_EQ(PrintServiceAbility::QueryPrinterProperties(printerId, keyList, valueList), E_PRINT_NONE);
974 }
975
TEST_F(nullTest,QueryPrinterProperties_ShouldReturnNone_WhenKeyNotPrinterPreference)976 TEST_F(nullTest, QueryPrinterProperties_ShouldReturnNone_WhenKeyNotPrinterPreference)
977 {
978 std::string printerId = "testPrinter";
979 std::vector std::stringundefined keyList = {"nonPrinterPreferenceKey"};
980 std::vector std::stringundefined valueList;
981 EXPECT_EQ(PrintServiceAbility::QueryPrinterProperties(printerId, keyList, valueList), E_PRINT_NONE);
982 }
983
TEST_F(nullTest,QueryPrintJobById_ShouldReturnNoPermission_WhenPermissionIsFalse)984 TEST_F(nullTest, QueryPrintJobById_ShouldReturnNoPermission_WhenPermissionIsFalse)
985 {
986 PrintServiceAbility printServiceAbility;
987 std::string printJobId = "testJobId";
988 PrintJob printJob;
989 EXPECT_EQ(printServiceAbility.QueryPrintJobById(printJobId, printJob), E_PRINT_NO_PERMISSION);
990 }
991
TEST_F(nullTest,QueryPrintJobById_ShouldReturnInvalidUserId_WhenUserDataIsNull)992 TEST_F(nullTest, QueryPrintJobById_ShouldReturnInvalidUserId_WhenUserDataIsNull)
993 {
994 PrintServiceAbility printServiceAbility;
995 std::string printJobId = "testJobId";
996 PrintJob printJob;
997 printServiceAbility.ManualStart();
998 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
999 EXPECT_EQ(printServiceAbility.QueryPrintJobById(printJobId, printJob), E_PRINT_INVALID_USERID);
1000 }
1001
TEST_F(nullTest,QueryPrintJobById_ShouldReturnQueryPrintJobByIdFailed_WhenQueryPrintJobByIdFails)1002 TEST_F(nullTest, QueryPrintJobById_ShouldReturnQueryPrintJobByIdFailed_WhenQueryPrintJobByIdFails)
1003 {
1004 PrintServiceAbility printServiceAbility;
1005 std::string printJobId = "testJobId";
1006 PrintJob printJob;
1007 printServiceAbility.ManualStart();
1008 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
1009 printServiceAbility.GetCurrentUserData = undefined { return nullptr; };
1010 EXPECT_EQ(printServiceAbility.QueryPrintJobById(printJobId, printJob), E_PRINT_INVALID_USERID);
1011 }
1012
TEST_F(nullTest,QueryPrintJobById_ShouldReturnNone_WhenAllChecksPass)1013 TEST_F(nullTest, QueryPrintJobById_ShouldReturnNone_WhenAllChecksPass)
1014 {
1015 PrintServiceAbility printServiceAbility;
1016 std::string printJobId = "testJobId";
1017 PrintJob printJob;
1018 printServiceAbility.ManualStart();
1019 printServiceAbility.CheckPermission = [](const std::string& permission) { return true; };
1020 printServiceAbility.GetCurrentUserData = undefined { return new UserData(); };
1021 EXPECT_EQ(printServiceAbility.QueryPrintJobById(printJobId, printJob), E_PRINT_NONE);
1022 }
1023
TEST_F(nullTest,AddPrinterToCups_ShouldReturnNoPermission_WhenPermissionIsFalse)1024 TEST_F(nullTest, AddPrinterToCups_ShouldReturnNoPermission_WhenPermissionIsFalse)
1025 {
1026 PrintServiceAbility printServiceAbility;
1027 printServiceAbility.ManualStart();
1028 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(false));
1029 EXPECT_EQ(printServiceAbility.AddPrinterToCups("uri", "name", "make"), E_PRINT_NO_PERMISSION);
1030 }
1031
TEST_F(nullTest,AddPrinterToCups_ShouldReturnNoError_WhenPermissionIsTrue)1032 TEST_F(nullTest, AddPrinterToCups_ShouldReturnNoError_WhenPermissionIsTrue)
1033 {
1034 PrintServiceAbility printServiceAbility;
1035 printServiceAbility.ManualStart();
1036 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
1037 EXPECT_CALL(printServiceAbility, DelayedSingleton<PrintCupsClient>::GetInstance()->
1038 AddPrinterToCups("uri", "name", "make")).WillOnce(Return(E_PRINT_NONE));
1039 EXPECT_EQ(printServiceAbility.AddPrinterToCups("uri", "name", "make"), E_PRINT_NONE);
1040 }
1041
TEST_F(nullTest,AddPrinterToCups_ShouldReturnAddPrinterToCupsError_WhenAddPrinterToCupsReturnsError)1042 TEST_F(nullTest, AddPrinterToCups_ShouldReturnAddPrinterToCupsError_WhenAddPrinterToCupsReturnsError)
1043 {
1044 PrintServiceAbility printServiceAbility;
1045 printServiceAbility.ManualStart();
1046 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
1047 EXPECT_CALL(printServiceAbility, DelayedSingleton<PrintCupsClient>::GetInstance()->
1048 AddPrinterToCups("uri", "name", "make")).WillOnce(Return(E_PRINT_ADD_PRINTER_TO_CUPS_ERROR));
1049 EXPECT_EQ(printServiceAbility.AddPrinterToCups("uri", "name", "make"), E_PRINT_ADD_PRINTER_TO_CUPS_ERROR);
1050 }
1051
TEST_F(nullTest,AddPrinterToCups_ShouldReturnNoError_WhenCUPSIsDisabled)1052 TEST_F(nullTest, AddPrinterToCups_ShouldReturnNoError_WhenCUPSIsDisabled)
1053 {
1054 PrintServiceAbility printServiceAbility;
1055 printServiceAbility.ManualStart();
1056 EXPECT_CALL(printServiceAbility, CheckPermission(PERMISSION_NAME_PRINT)).WillOnce(Return(true));
1057 EXPECT_EQ(printServiceAbility.AddPrinterToCups("uri", "name", "make"), E_PRINT_NONE);
1058 }
1059
1060 class DelayedSingletonTest : public nullTest {
1061 public:
1062 DelayedSingleton<PrintCupsClient>* instance;
SetUp()1063 void SetUp() override
1064 {
1065 instance = DelayedSingleton<PrintCupsClient>::GetInstance();
1066 }
TearDown()1067 void TearDown() override {}
1068 };
TEST_F(DelayedSingletonTest,GetInstance_ShouldReturnNonNull)1069 TEST_F(DelayedSingletonTest, GetInstance_ShouldReturnNonNull)
1070 {
1071 EXPECT_NE(instance, nullptr);
1072 }
1073
TEST_F(DelayedSingletonTest,AddPrinterToCups_ShouldReturnNoneWhenSuccessful)1074 TEST_F(DelayedSingletonTest, AddPrinterToCups_ShouldReturnNoneWhenSuccessful)
1075 {
1076 std::string printerUri = "testUri";
1077 std::string printerName = "testName";
1078 bool make = true;
1079 struct PrinterInfo {
1080 std::string GetPrinterName()
1081 {
1082 return printerName;
1083 }
1084 };
1085 PrinterInfo printerInfo;
1086 auto ret = instance->AddPrinterToCups(printerUri, printerInfo.GetPrinterName(), make);
1087 EXPECT_EQ(ret, E_PRINT_NONE);
1088 }
1089
TEST_F(DelayedSingletonTest,AddPrinterToCups_ShouldReturnErrorWhenNotSuccessful)1090 TEST_F(DelayedSingletonTest, AddPrinterToCups_ShouldReturnErrorWhenNotSuccessful)
1091 {
1092 std::string printerUri = "testUri";
1093 std::string printerName = "testName";
1094 bool make = true;
1095 struct PrinterInfo {
1096 std::string GetPrinterName()
1097 {
1098 return printerName;
1099 }
1100 };
1101 PrinterInfo printerInfo;
1102 auto ret = instance->AddPrinterToCups(printerUri, printerInfo.GetPrinterName(), make);
1103 EXPECT_NE(ret, E_PRINT_NONE);
1104 }
1105
TEST_F(DelayedSingletonTest,QueryPrinterCapabilityFromPPD_ShouldReturnNoneWhenSuccessful)1106 TEST_F(DelayedSingletonTest, QueryPrinterCapabilityFromPPD_ShouldReturnNoneWhenSuccessful)
1107 {
1108 struct PrinterInfo {
1109 std::string GetPrinterName()
1110 {
1111 return "testName";
1112 }
1113 };
1114 PrinterInfo printerInfo;
1115 instance->QueryPrinterCapabilityFromPPD(printerInfo.GetPrinterName(), printerCaps);
1116 EXPECT_EQ(ret, E_PRINT_NONE);
1117 }
1118
TEST_F(DelayedSingletonTest,QueryPrinterCapabilityByUri_ShouldReturnNoneWhenSuccessful)1119 TEST_F(DelayedSingletonTest, QueryPrinterCapabilityByUri_ShouldReturnNoneWhenSuccessful)
1120 {
1121 std::string printerUri = "testUri";
1122 std::string printerId = "testId";
1123 instance->QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
1124 EXPECT_EQ(ret, E_PRINT_NONE);
1125 }
1126
TEST_F(nullTest,testBuildPrinterPreferenceByOption)1127 TEST_F(nullTest, testBuildPrinterPreferenceByOption)
1128 {
1129 std::string key = "testKey";
1130 std::string supportedOpts = "";
1131 std::vector std::stringundefined optAttrs;
1132 PrintServiceAbility::BuildPrinterPreferenceByOption(key, supportedOpts, optAttrs);
1133 EXPECT_TRUE(optAttrs.empty());
1134 }
1135
TEST_F(nullTest,testBuildPrinterPreferenceByOptionWithJson)1136 TEST_F(nullTest, testBuildPrinterPreferenceByOptionWithJson)
1137 {
1138 std::string key = "testKey";
1139 std::string supportedOpts = "{"key":"value"}";
1140 std::vector std::stringundefined optAttrs;
1141 PrintServiceAbility::BuildPrinterPreferenceByOption(key, supportedOpts, optAttrs);
1142 EXPECT_FALSE(optAttrs.empty());
1143 EXPECT_EQ(optAttrs[0], "value");
1144 }
1145
TEST_F(nullTest,testBuildPrinterPreferenceByOptionWithNonJson)1146 TEST_F(nullTest, testBuildPrinterPreferenceByOptionWithNonJson)
1147 {
1148 std::string key = "testKey";
1149 std::string supportedOpts = "nonJsonString";
1150 std::vector std::stringundefined optAttrs;
1151 PrintServiceAbility::BuildPrinterPreferenceByOption(key, supportedOpts, optAttrs);
1152 EXPECT_FALSE(optAttrs.empty());
1153 EXPECT_EQ(optAttrs[0], "nonJsonString");
1154 }
1155
TEST_F(nullTest,testBuildPrinterPreferenceByOptionWithEmptyString)1156 TEST_F(nullTest, testBuildPrinterPreferenceByOptionWithEmptyString)
1157 {
1158 std::string key = "testKey";
1159 std::string supportedOpts = "";
1160 std::vector std::stringundefined optAttrs;
1161 PrintServiceAbility::BuildPrinterPreferenceByOption(key, supportedOpts, optAttrs);
1162 EXPECT_TRUE(optAttrs.empty());
1163 }
1164
TEST_F(nullTest,BuildPrinterPreference_Test)1165 TEST_F(nullTest, BuildPrinterPreference_Test)
1166 {
1167 PrinterCapability cap;
1168 PrinterPreference printPreference;
1169 int32_t result = PrintServiceAbility::BuildPrinterPreference(cap, printPreference);
1170 EXPECT_EQ(result, E_PRINT_INVALID_PARAMETER);
1171 }
1172
TEST_F(nullTest,BuildPrinterPreference_Test2)1173 TEST_F(nullTest, BuildPrinterPreference_Test2)
1174 {
1175 PrinterCapability cap;
1176 cap.SetOption("{"cupsOptions":{"orientation-requested-supported":"landscape"}}");
1177 PrinterPreference printPreference;
1178 int32_t result = PrintServiceAbility::BuildPrinterPreference(cap, printPreference);
1179 EXPECT_EQ(result, E_PRINT_NONE);
1180 }
1181
TEST_F(nullTest,BuildPrinterPreference_Test3)1182 TEST_F(nullTest, BuildPrinterPreference_Test3)
1183 {
1184 PrinterCapability cap;
1185 cap.SetOption("{"cupsOptions":{"sides-supported":"one-sided"}}");
1186 PrinterPreference printPreference;
1187 int32_t result = PrintServiceAbility::BuildPrinterPreference(cap, printPreference);
1188 EXPECT_EQ(result, E_PRINT_NONE);
1189 }
1190
TEST_F(nullTest,BuildPrinterPreference_Test4)1191 TEST_F(nullTest, BuildPrinterPreference_Test4)
1192 {
1193 PrinterCapability cap;
1194 cap.SetOption("{"cupsOptions":{"print-quality-supported":"draft"}}");
1195 PrinterPreference printPreference;
1196 int32_t result = PrintServiceAbility::BuildPrinterPreference(cap, printPreference);
1197 EXPECT_EQ(result, E_PRINT_NONE);
1198 }
1199
TEST_F(nullTest,BuildPrinterPreference_Test5)1200 TEST_F(nullTest, BuildPrinterPreference_Test5)
1201 {
1202 PrinterCapability cap;
1203 cap.SetOption("{"cupsOptions":{"orientation-requested-supported":"portrait"}}");
1204 cap.SetOption("{"cupsOptions":{"sides-supported":"two-sided-long-edge"}}");
1205 cap.SetOption("{"cupsOptions":{"print-quality-supported":"standard"}}");
1206 PrinterPreference printPreference;
1207 int32_t result = PrintServiceAbility::BuildPrinterPreference(cap, printPreference);
1208 EXPECT_EQ(result, E_PRINT_NONE);
1209 }
1210
1211 class PrintServiceAbilityTest : public nullTest {
1212 public:
1213 PrintServiceAbility* printServiceAbility;
1214 std::string printerId;
1215 std::string printerPreference;
SetUp()1216 void SetUp() override
1217 {
1218 printServiceAbility = new PrintServiceAbility();
1219 }
TearDown()1220 void TearDown() override
1221 {
1222 delete printServiceAbility;
1223 printServiceAbility = nullptr
1224 }
1225 };
1226 HWTEST_F(PrintServiceAbilityTest, GetPrinterPreference_ShouldReturnNoPermission_WhenNoPermission, TestSize.Level0)
1227 {
1228 printerId = "testPrinter";
1229 printerPreference = "";
1230 printServiceAbility->apiMutex_.lock();
__anon6a3cc7ef1302(const std::string& permission) 1231 printServiceAbility->CheckPermission = [](const std::string& permission) { return false; };
1232 int32_t result = printServiceAbility->GetPrinterPreference(printerId, printerPreference);
1233 EXPECT_EQ(result, E_PRINT_NO_PERMISSION);
1234 }
1235 HWTEST_F(PrintServiceAbilityTest,
1236 GetPrinterPreference_ShouldReturnInvalidPrinter_WhenPreferenceMapIsEmpty, TestSize.Level0)
1237 {
1238 printerId = "testPrinter";
1239 printerPreference = "";
1240 printServiceAbility->apiMutex_.lock();
__anon6a3cc7ef1402(const std::string& permission) 1241 printServiceAbility->CheckPermission = [](const std::string& permission) { return true; };
1242 printServiceAbility->printerIdAndPreferenceMap_.clear();
1243 int32_t result = printServiceAbility->GetPrinterPreference(printerId, printerPreference);
1244 EXPECT_EQ(result, E_PRINT_INVALID_PRINTER);
1245 }
1246 HWTEST_F(PrintServiceAbilityTest, GetPrinterPreference_ShouldReturnNone_WhenPreferenceIsReadFromFile, TestSize.Level0)
1247 {
1248 printerId = "testPrinter";
1249 printerPreference = "";
1250 printServiceAbility->apiMutex_.lock();
__anon6a3cc7ef1502(const std::string& permission) 1251 printServiceAbility->CheckPermission = [](const std::string& permission) { return true; };
1252 printServiceAbility->printerIdAndPreferenceMap_.insert({printerId, "TestPreference"});
1253 printServiceAbility->ReadPreferenceFromFile = [](const std::string& id, std::string& preference)
__anon6a3cc7ef1602(const std::string& id, std::string& preference) 1254 {
1255 preference = "TestPreference";
1256 return true;
1257 };
1258 int32_t result = printServiceAbility->GetPrinterPreference(printerId, printerPreference);
1259 EXPECT_EQ(result, E_PRINT_NONE);
1260 EXPECT_EQ(printerPreference, "TestPreference");
1261 }
1262
1263 HWTEST_F(nullTest, SetPrinterPreference_ShouldReturnPermissionError_WhenNoPermission, TestSize.Level0)
1264 {
1265 PrintServiceAbility ability;
1266 std::string printerId = "printer1";
1267 std::string printerSetting = "{"key":"value"}";
1268 int result = ability.SetPrinterPreference(printerId, printerSetting);
1269 EXPECT_EQ(result, E_PRINT_NO_PERMISSION);
1270 }
1271
1272 HWTEST_F(nullTest, SetPrinterPreference_ShouldReturnSuccess_WhenPreferenceNotExists, TestSize.Level0)
1273 {
1274 PrintServiceAbility ability;
1275 std::string printerId = "printer1";
1276 std::string printerSetting = "{"key":"value"}";
__anon6a3cc7ef1702(const std::string& permission) 1277 ability.CheckPermission = [](const std::string& permission) { return true; };
1278 int result = ability.SetPrinterPreference(printerId, printerSetting);
1279 EXPECT_EQ(result, E_PRINT_NONE);
1280 }
1281
1282 HWTEST_F(nullTest, SetPrinterPreference_ShouldReturnInvalidPrinterError_WhenSettingInvalid, TestSize.Level0)
1283 {
1284 PrintServiceAbility ability;
1285 std::string printerId = "printer1";
1286 std::string printerSetting = "invalid_json";
__anon6a3cc7ef1802(const std::string& permission) 1287 ability.CheckPermission = [](const std::string& permission) { return true; };
1288 ability.printerIdAndPreferenceMap_.insert({printerId, "valid_json"});
1289 int result = ability.SetPrinterPreference(printerId, printerSetting);
1290 EXPECT_EQ(result, E_PRINT_INVALID_PRINTER);
1291 }
1292
1293 HWTEST_F(nullTest, SetPrinterPreference_ShouldReturnServerError_WhenWriteFileFails, TestSize.Level0)
1294 {
1295 PrintServiceAbility ability;
1296 std::string printerId = "printer1";
1297 std::string printerSetting = "{"key":"value"}";
__anon6a3cc7ef1902(const std::string& permission) 1298 ability.CheckPermission = [](const std::string& permission) { return true; };
1299 ability.printerIdAndPreferenceMap_.insert({printerId, "valid_json"});
1300 ability.WritePreferenceToFile = undefined { return false; };
1301 int result = ability.SetPrinterPreference(printerId, printerSetting);
1302 EXPECT_EQ(result, E_PRINT_SERVER_FAILURE);
1303 }
1304
1305 HWTEST_F(nullTest, SetPrinterPreference_ShouldReturnSuccess_WhenPreferenceSetSuccessfully, TestSize.Level0)
1306 {
1307 PrintServiceAbility ability;
1308 std::string printerId = "printer1";
1309 std::string printerSetting = "{"key":"value"}";
__anon6a3cc7ef1a02(const std::string& permission) 1310 ability.CheckPermission = [](const std::string& permission) { return true; };
1311 ability.printerIdAndPreferenceMap_.insert({printerId, "valid_json"});
1312 ability.WritePreferenceToFile = undefined { return true; };
1313 int result = ability.SetPrinterPreference(printerId, printerSetting);
1314 EXPECT_EQ(result, E_PRINT_NONE);
1315 }
1316
1317 class PrintServiceAbilityTest : public nullTest {
1318 public:
1319 PrintServiceAbility* printServiceAbility;
SetUp()1320 void SetUp() override
1321 {
1322 printServiceAbility = new PrintServiceAbility();
1323 }
TearDown()1324 void TearDown() override
1325 {
1326 delete printServiceAbility;
1327 printServiceAbility = nullptr
1328 }
1329 };
1330 HWTEST_F(PrintServiceAbilityTest, ReadPreferenceFromFile_ShouldReturnTrue_WhenPrinterIdExists, TestSize.Level0)
1331 {
1332 std::string printerId = "printer1";
1333 std::string printPreference;
1334 EXPECT_TRUE(printServiceAbility->ReadPreferenceFromFile(printerId, printPreference));
1335 EXPECT_EQ(printPreference, "high");
1336 }
1337 HWTEST_F(PrintServiceAbilityTest, ReadPreferenceFromFile_ShouldReturnFalse_WhenPrinterIdDoesNotExist, TestSize.Level0)
1338 {
1339 std::string printerId = "nonexistentprinter";
1340 std::string printPreference;
1341 EXPECT_FALSE(printServiceAbility->ReadPreferenceFromFile(printerId, printPreference));
1342 EXPECT_EQ(printPreference, "");
1343 }
1344 HWTEST_F(PrintServiceAbilityTest, ReadPreferenceFromFile_ShouldReturnFalse_WhenPrintPreferenceIsEmpty, TestSize.Level0)
1345 {
1346 std::string printerId = "";
1347 std::string printPreference;
1348 EXPECT_FALSE(printServiceAbility->ReadPreferenceFromFile(printerId, printPreference));
1349 EXPECT_EQ(printPreference, "");
1350 }
1351
TEST_F(nullTest,InitPreferenceMap_Test)1352 TEST_F(nullTest, InitPreferenceMap_Test)
1353 {
1354 PrintServiceAbility printServiceAbility;
1355 printServiceAbility.InitPreferenceMap();
1356 EXPECT_EQ(printServiceAbility.printerIdAndPreferenceMap_.size(), 0);
1357 }
1358
TEST_F(nullTest,WritePreferenceToFile_ShouldReturnFalse_WhenPathDoesNotExist)1359 TEST_F(nullTest,
1360 WritePreferenceToFile_ShouldReturnFalse_WhenPathDoesNotExist)
1361 {
1362 PrintServiceAbility printServiceAbility;
1363 char realPidFile[PATH_MAX] = {};
1364 EXPECT_CALL(printServiceAbility, realpath(PRINTER_SERVICE_FILE_PATH.c_str(), realPidFile))
1365 .WillOnce(Return(nullptr));
1366 EXPECT_FALSE(printServiceAbility.WritePreferenceToFile());
1367 }
1368
TEST_F(nullTest,WritePreferenceToFile_ShouldReturnFalse_WhenFileOpenFails)1369 TEST_F(nullTest,
1370 WritePreferenceToFile_ShouldReturnFalse_WhenFileOpenFails)
1371 {
1372 PrintServiceAbility printServiceAbility;
1373 char realPidFile[PATH_MAX] = "/valid/path";
1374 EXPECT_CALL(printServiceAbility, realpath(PRINTER_SERVICE_FILE_PATH.c_str(), realPidFile))
1375 .WillOnce(Return(realPidFile));
1376 EXPECT_CALL(printServiceAbility, open(PRINTER_PREFERENCE_FILE.c_str(), O_CREAT | O_TRUNC | O_RDWR, S_IRUSR))
1377 .WillOnce(Return(-1));
1378 EXPECT_FALSE(printServiceAbility.WritePreferenceToFile());
1379 }
1380
TEST_F(nullTest,WritePreferenceToFile_ShouldReturnFalse_WhenWriteFails)1381 TEST_F(nullTest,
1382 WritePreferenceToFile_ShouldReturnFalse_WhenWriteFails)
1383 {
1384 PrintServiceAbility printServiceAbility;
1385 char realPidFile[PATH_MAX] = "/valid/path";
1386 EXPECT_CALL(printServiceAbility, realpath(PRINTER_SERVICE_FILE_PATH.c_str(), realPidFile))
1387 .WillOnce(Return(realPidFile));
1388 int32_t fd = 1;
1389 EXPECT_CALL(printServiceAbility, open(PRINTER_PREFERENCE_FILE.c_str(), O_CREAT | O_TRUNC | O_RDWR, S_IRUSR))
1390 .WillOnce(Return(fd));
1391 EXPECT_CALL(printServiceAbility, write(fd, _, _))
1392 .WillOnce(Return(0));
1393 EXPECT_FALSE(printServiceAbility.WritePreferenceToFile());
1394 }
1395
TEST_F(nullTest,WritePreferenceToFile_ShouldReturnTrue_WhenWriteSucceeds)1396 TEST_F(nullTest,
1397 WritePreferenceToFile_ShouldReturnTrue_WhenWriteSucceeds)
1398 {
1399 PrintServiceAbility printServiceAbility;
1400 char realPidFile[PATH_MAX] = "/valid/path";
1401 EXPECT_CALL(printServiceAbility, realpath(PRINTER_SERVICE_FILE_PATH.c_str(), realPidFile))
1402 .WillOnce(Return(realPidFile));
1403 int32_t fd = 1;
1404 EXPECT_CALL(printServiceAbility, open(PRINTER_PREFERENCE_FILE.c_str(), O_CREAT | O_TRUNC | O_RDWR, S_IRUSR))
1405 .WillOnce(Return(fd));
1406 EXPECT_CALL(printServiceAbility, write(fd, _, _))
1407 .WillOnce(Return(fd));
1408 EXPECT_TRUE(printServiceAbility.WritePreferenceToFile());
1409 }
1410
1411 class PrintServiceAbilityTest : public nullTest {
1412 public:
1413 PrintServiceAbility* printServiceAbility;
1414 std::string printerId;
1415 PrinterCapability printerCaps;
SetUp()1416 void SetUp() override
1417 {
1418 printServiceAbility = new PrintServiceAbility();
1419 printerId = "testPrinter";
1420 printerCaps.AddOption("testOption");
1421 }
TearDown()1422 void TearDown() override
1423 {
1424 delete printServiceAbility;
1425 printServiceAbility = nullptr
1426 }
1427 };
1428 HWTEST_F(PrintServiceAbilityTest,
1429 WritePrinterPreference_ShouldReturnFalse_WhenPrinterCapsHasNoOption, TestSize.Level0)
1430 {
1431 printerCaps.RemoveOption("testOption");
1432 EXPECT_FALSE(printServiceAbility->WritePrinterPreference(printerId, printerCaps));
1433 }
1434 HWTEST_F(PrintServiceAbilityTest,
1435 WritePrinterPreference_ShouldReturnFalse_WhenPrinterIdAndPreferenceMapContainsPrinterId, TestSize.Level0)
1436 {
1437 printServiceAbility->printerIdAndPreferenceMap_.insert(std::make_pair(printerId, "testPreference"));
1438 EXPECT_FALSE(printServiceAbility->WritePrinterPreference(printerId, printerCaps));
1439 }
1440 HWTEST_F(PrintServiceAbilityTest,
1441 WritePrinterPreference_ShouldReturnFalse_WhenBuildPrinterPreferenceFails, TestSize.Level0)
1442 {
1443 EXPECT_CALL(*printServiceAbility, BuildPrinterPreference(_, _)).WillOnce(Return(1));
1444 EXPECT_FALSE(printServiceAbility->WritePrinterPreference(printerId, printerCaps));
1445 }
1446 HWTEST_F(PrintServiceAbilityTest,
1447 WritePrinterPreference_ShouldReturnTrue_WhenWritePreferenceToFileFails, TestSize.Level0)
1448 {
1449 EXPECT_CALL(*printServiceAbility, WritePreferenceToFile()).WillOnce(Return(false));
1450 EXPECT_FALSE(printServiceAbility->WritePrinterPreference(printerId, printerCaps));
1451 }
1452 HWTEST_F(PrintServiceAbilityTest,
1453 WritePrinterPreference_ShouldReturnTrue_WhenAllConditionsMet, TestSize.Level0)
1454 {
1455 EXPECT_CALL(*printServiceAbility, BuildPrinterPreference(_, _)).WillOnce(Return(0));
1456 EXPECT_CALL(*printServiceAbility, WritePreferenceToFile()).WillOnce(Return(true));
1457 EXPECT_TRUE(printServiceAbility->WritePrinterPreference(printerId, printerCaps));
1458 }
1459
TEST_F(nullTest,WriteEprinterPreference_Test)1460 TEST_F(nullTest,
1461 WriteEprinterPreference_Test)
1462 {
1463 PrintServiceAbility printServiceAbility;
1464 std::string printerId = "testPrinter";
1465 PrinterCapability printerCaps;
1466 EXPECT_EQ(printServiceAbility.WriteEprinterPreference(printerId, printerCaps), true);
1467 }
1468
TEST_F(nullTest,WriteEprinterPreference_Test_Fail)1469 TEST_F(nullTest,
1470 WriteEprinterPreference_Test_Fail)
1471 {
1472 PrintServiceAbility printServiceAbility;
1473 std::string printerId = "testPrinter";
1474 PrinterCapability printerCaps;
1475 printServiceAbility.WriteEprinterPreference(printerId, printerCaps);
1476 EXPECT_EQ(printServiceAbility.WriteEprinterPreference(printerId, printerCaps), false);
1477 }
1478
TEST_F(nullTest,WriteEprinterPreference_Test_UnsupportedPageSize)1479 TEST_F(nullTest,
1480 WriteEprinterPreference_Test_UnsupportedPageSize)
1481 {
1482 PrintServiceAbility printServiceAbility;
1483 std::string printerId = "testPrinter";
1484 PrinterCapability printerCaps;
1485 printerCaps.SetSupportedPageSize({PrintPageSize("A4")});
1486 EXPECT_EQ(printServiceAbility.WriteEprinterPreference(printerId, printerCaps), true);
1487 }
1488
TEST_F(nullTest,WriteEprinterPreference_Test_UnsupportedOrientation)1489 TEST_F(nullTest,
1490 WriteEprinterPreference_Test_UnsupportedOrientation)
1491 {
1492 PrintServiceAbility printServiceAbility;
1493 std::string printerId = "testPrinter";
1494 PrinterCapability printerCaps;
1495 printerCaps.SetSupportedOrientation({PORTRAIT, LANDSCAPE});
1496 EXPECT_EQ(printServiceAbility.WriteEprinterPreference(printerId, printerCaps), true);
1497 }
1498
TEST_F(nullTest,WriteEprinterPreference_Test_UnsupportedDuplexMode)1499 TEST_F(nullTest,
1500 WriteEprinterPreference_Test_UnsupportedDuplexMode)
1501 {
1502 PrintServiceAbility printServiceAbility;
1503 std::string printerId = "testPrinter";
1504 PrinterCapability printerCaps;
1505 printerCaps.SetSupportedDuplexMode({SIMPLEX, DUPLEX});
1506 EXPECT_EQ(printServiceAbility.WriteEprinterPreference(printerId, printerCaps), true);
1507 }
1508
TEST_F(nullTest,WriteEprinterPreference_Test_UnsupportedQuality)1509 TEST_F(nullTest,
1510 WriteEprinterPreference_Test_UnsupportedQuality)
1511 {
1512 PrintServiceAbility printServiceAbility;
1513 std::string printerId = "testPrinter";
1514 PrinterCapability printerCaps;
1515 printerCaps.SetSupportedQuality({HIGH, LOW});
1516 EXPECT_EQ(printServiceAbility.WriteEprinterPreference(printerId, printerCaps), true);
1517 }
1518
TEST_F(nullTest,UpdatePrintJobOptionByPrinterId_Test)1519 TEST_F(nullTest, UpdatePrintJobOptionByPrinterId_Test)
1520 {
1521 PrintJob printJob;
1522 printJob.SetPrinterId("printerId");
1523 printJob.SetOption("{"key":"value"}");
1524 PrintServiceAbility printServiceAbility;
1525 EXPECT_TRUE(printServiceAbility.UpdatePrintJobOptionByPrinterId(printJob));
1526 }
1527
TEST_F(nullTest,UpdatePrintJobOptionByPrinterId_Test_Fail)1528 TEST_F(nullTest, UpdatePrintJobOptionByPrinterId_Test_Fail)
1529 {
1530 PrintJob printJob;
1531 printJob.SetPrinterId("nonexistentPrinterId");
1532 printJob.SetOption("{"key":"value"}");
1533 PrintServiceAbility printServiceAbility;
1534 EXPECT_FALSE(printServiceAbility.UpdatePrintJobOptionByPrinterId(printJob));
1535 }
1536
TEST_F(nullTest,UpdatePrintJobOptionByPrinterId_Test_InvalidOption)1537 TEST_F(nullTest, UpdatePrintJobOptionByPrinterId_Test_InvalidOption)
1538 {
1539 PrintJob printJob;
1540 printJob.SetPrinterId("printerId");
1541 printJob.SetOption("invalidJson");
1542 PrintServiceAbility printServiceAbility;
1543 EXPECT_FALSE(printServiceAbility.UpdatePrintJobOptionByPrinterId(printJob));
1544 }
1545
TEST_F(nullTest,AddNativePrintJob_ShouldReturnNullptr_WhenNativePrintJobIsNull)1546 TEST_F(nullTest, AddNativePrintJob_ShouldReturnNullptr_WhenNativePrintJobIsNull)
1547 {
1548 PrintServiceAbility printServiceAbility;
1549 std::string jobId = "testJobId";
1550 PrintJob printJob;
1551 auto result = printServiceAbility.AddNativePrintJob(jobId, printJob);
1552 EXPECT_EQ(result, nullptr);
1553 }
1554
TEST_F(nullTest,AddNativePrintJob_ShouldReturnNonNullptr_WhenNativePrintJobIsNotNull)1555 TEST_F(nullTest, AddNativePrintJob_ShouldReturnNonNullptr_WhenNativePrintJobIsNotNull)
1556 {
1557 PrintServiceAbility printServiceAbility;
1558 std::string jobId = "testJobId";
1559 PrintJob printJob;
1560 printJob.SetJobId(jobId);
1561 printJob.SetJobState(PRINT_JOB_PREPARED);
1562 auto result = printServiceAbility.AddNativePrintJob(jobId, printJob);
1563 EXPECT_NE(result, nullptr);
1564 }
1565
TEST_F(nullTest,AddNativePrintJob_ShouldUpdateParamsAndDump_WhenNativePrintJobIsNotNull)1566 TEST_F(nullTest, AddNativePrintJob_ShouldUpdateParamsAndDump_WhenNativePrintJobIsNotNull)
1567 {
1568 PrintServiceAbility printServiceAbility;
1569 std::string jobId = "testJobId";
1570 PrintJob printJob;
1571 printJob.SetJobId(jobId);
1572 printJob.SetJobState(PRINT_JOB_PREPARED);
1573 auto result = printServiceAbility.AddNativePrintJob(jobId, printJob);
1574 EXPECT_NE(result, nullptr);
1575 EXPECT_EQ(result->GetJobId(), jobId);
1576 EXPECT_EQ(result->GetJobState(), PRINT_JOB_PREPARED);
1577 }
1578
TEST_F(nullTest,AddNativePrintJob_ShouldAddToPrintJobList_WhenNativePrintJobIsNotNull)1579 TEST_F(nullTest, AddNativePrintJob_ShouldAddToPrintJobList_WhenNativePrintJobIsNotNull)
1580 {
1581 PrintServiceAbility printServiceAbility;
1582 std::string jobId = "testJobId";
1583 PrintJob printJob;
1584 printJob.SetJobId(jobId);
1585 printJob.SetJobState(PRINT_JOB_PREPARED);
1586 auto result = printServiceAbility.AddNativePrintJob(jobId, printJob);
1587 EXPECT_NE(result, nullptr);
1588 EXPECT_TRUE(printServiceAbility.CheckPrintJobInList(jobId));
1589 }
1590
TEST_F(nullTest,StartPrintJob_ShouldReturnNoPermission_WhenPermissionIsFalse)1591 TEST_F(nullTest, StartPrintJob_ShouldReturnNoPermission_WhenPermissionIsFalse)
1592 {
1593 PrintServiceAbility printServiceAbility;
1594 PrintJob jobInfo;
1595 EXPECT_EQ(printServiceAbility.StartPrintJob(jobInfo), E_PRINT_NO_PERMISSION);
1596 }
1597
TEST_F(nullTest,StartPrintJob_ShouldReturnInvalidPrintJob_WhenCheckPrintJobIsFalse)1598 TEST_F(nullTest, StartPrintJob_ShouldReturnInvalidPrintJob_WhenCheckPrintJobIsFalse)
1599 {
1600 PrintServiceAbility printServiceAbility;
1601 PrintJob jobInfo;
1602 EXPECT_EQ(printServiceAbility.StartPrintJob(jobInfo), E_PRINT_INVALID_PRINTJOB);
1603 }
1604
TEST_F(nullTest,StartPrintJob_ShouldReturnSuccess_WhenAllConditionsAreMet)1605 TEST_F(nullTest, StartPrintJob_ShouldReturnSuccess_WhenAllConditionsAreMet)
1606 {
1607 PrintServiceAbility printServiceAbility;
1608 PrintJob jobInfo;
1609 EXPECT_EQ(printServiceAbility.StartPrintJob(jobInfo), 0);
1610 }
1611
1612 class PrintServiceAbilityTest : public nullTest {
1613 public:
1614 PrintServiceAbility ability;
1615 PrintJob jobInfo;
1616 };
TEST_F(PrintServiceAbilityTest,CheckPrintJob_ShouldReturnFalse_WhenUpdatePrintJobOptionByPrinterIdFails)1617 TEST_F(PrintServiceAbilityTest, CheckPrintJob_ShouldReturnFalse_WhenUpdatePrintJobOptionByPrinterIdFails)
1618 {
1619 int jobId = 1;
1620 jobInfo.SetJobId(jobId);
1621 EXPECT_CALL(ability, UpdatePrintJobOptionByPrinterId(_)).WillOnce(Return(false));
1622 bool result = ability.CheckPrintJob(jobInfo);
1623 EXPECT_FALSE(result);
1624 }
1625
TEST_F(PrintServiceAbilityTest,CheckPrintJob_ShouldReturnFalse_WhenJobIdNotFound)1626 TEST_F(PrintServiceAbilityTest, CheckPrintJob_ShouldReturnFalse_WhenJobIdNotFound)
1627 {
1628 int jobId = 2;
1629 jobInfo.SetJobId(jobId);
1630 EXPECT_CALL(ability, UpdatePrintJobOptionByPrinterId(_)).WillOnce(Return(true));
1631 EXPECT_CALL(ability, GetJobId()).WillOnce(Return(jobId));
1632 bool result = ability.CheckPrintJob(jobInfo);
1633 EXPECT_FALSE(result);
1634 }
1635
TEST_F(PrintServiceAbilityTest,CheckPrintJob_ShouldReturnTrue_WhenJobIdFoundAndUpdated)1636 TEST_F(PrintServiceAbilityTest, CheckPrintJob_ShouldReturnTrue_WhenJobIdFoundAndUpdated)
1637 {
1638 int jobId = 3;
1639 jobInfo.SetJobId(jobId);
1640 EXPECT_CALL(ability, UpdatePrintJobOptionByPrinterId()).WillOnce(Return(true));
1641 EXPECT_CALL(ability, GetJobId()).WillOnce(Return(jobId));
1642 EXPECT_CALL(ability, printJobList.find()).WillOnce(Return(ability.printJobList.end()));
1643 bool result = ability.CheckPrintJob(jobInfo);
1644 EXPECT_TRUE(result);
1645 }
1646
1647 class PrintServiceAbilityTest : public nullTest {
1648 public:
1649 PrintServiceAbility *printServiceAbility;
SetUp()1650 void SetUp() override
1651 {
1652 printServiceAbility = new PrintServiceAbility();
1653 }
TearDown()1654 void TearDown() override
1655 {
1656 delete printServiceAbility;
1657 printServiceAbility = nullptr
1658 }
1659 };
TEST_F(PrintServiceAbilityTest,SetLastUsedPrinter_ShouldPrintError_WhenPrinterNotAdded)1660 TEST_F(PrintServiceAbilityTest, SetLastUsedPrinter_ShouldPrintError_WhenPrinterNotAdded)
1661 {
1662 std::string printerId = "NonExistentPrinter";
1663 printServiceAbility->printSystemData_.IsPrinterAdded = [](const std::string &printerId) { return false; };
1664 printServiceAbility->SetLastUsedPrinter(printerId);
1665 EXPECT_EQ(printServiceAbility->userData_, nullptr);
1666 }
1667
TEST_F(PrintServiceAbilityTest,SetLastUsedPrinter_ShouldPrintError_WhenUserDataIsNull)1668 TEST_F(PrintServiceAbilityTest, SetLastUsedPrinter_ShouldPrintError_WhenUserDataIsNull)
1669 {
1670 std::string printerId = "ValidPrinter";
1671 printServiceAbility->printSystemData_.IsPrinterAdded = [](const std::string &printerId) { return true; };
1672 printServiceAbility->GetCurrentUserData = undefined { return nullptr; };
1673 printServiceAbility->SetLastUsedPrinter(printerId);
1674 EXPECT_EQ(printServiceAbility->userData_, nullptr);
1675 }
1676
TEST_F(PrintServiceAbilityTest,SetLastUsedPrinter_ShouldSetPrinter_WhenPrinterAddedAndUserDataValid)1677 TEST_F(PrintServiceAbilityTest, SetLastUsedPrinter_ShouldSetPrinter_WhenPrinterAddedAndUserDataValid)
1678 {
1679 std::string printerId = "ValidPrinter";
1680 printServiceAbility->printSystemData_.IsPrinterAdded = [](const std::string &printerId) { return true; };
1681 printServiceAbility->getCurrentUserData = undefined { return new UserData(); };
1682 printServiceAbility->userData_->SetLastUsedPrinter = [](const std::string &printerId) { return E_PRINT_NONE; };
1683 printServiceAbility->SetLastUsedPrinter(printerId);
1684 EXPECT_EQ(printServiceAbility->userData_->lastUsedPrinterId_, printerId);
1685 }
1686
1687 class PrintServiceAbilityTest : public nullTest {
1688 public:
SetUp()1689 void SetUp() override
1690 {
1691 printServiceAbility = new PrintServiceAbility();
1692 }
TearDown()1693 void TearDown() override
1694 {
1695 delete printServiceAbility;
1696 printServiceAbility = nullptr
1697 }
1698 PrintServiceAbility* printServiceAbility;
1699 };
1700 HWTEST_F(PrintServiceAbilityTest,
1701 StartPrintJobCB_ShouldSetJobStateAndNotifyAppJobQueueChanged_WhenCalled, TestSize.Level0)
1702 {
1703 std::string jobId = "testJobId";
1704 std::shared_ptr<PrintJob> printJob = std::make_shared<PrintJob>();
1705 printServiceAbility->StartPrintJobCB(jobId, printJob);
1706 EXPECT_EQ(printJob->GetJobState(), PRINT_JOB_QUEUED);
1707 }
1708
TEST_F(nullTest,CancelPrintJob_ShouldReturnNoPermission_WhenNoPermission)1709 TEST_F(nullTest, CancelPrintJob_ShouldReturnNoPermission_WhenNoPermission)
1710 {
1711 PrintServiceAbility printService;
1712 std::string jobId = "testJobId";
1713 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NO_PERMISSION);
1714 }
1715
TEST_F(nullTest,CancelPrintJob_ShouldReturnInvalidUserId_WhenUserDataIsNull)1716 TEST_F(nullTest, CancelPrintJob_ShouldReturnInvalidUserId_WhenUserDataIsNull)
1717 {
1718 PrintServiceAbility printService;
1719 std::string jobId = "testJobId";
1720 printService.ManualStart();
1721 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1722 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_INVALID_USERID);
1723 }
1724
TEST_F(nullTest,CancelPrintJob_ShouldReturnInvalidPrintJob_WhenJobNotFound)1725 TEST_F(nullTest, CancelPrintJob_ShouldReturnInvalidPrintJob_WhenJobNotFound)
1726 {
1727 PrintServiceAbility printService;
1728 std::string jobId = "testJobId";
1729 printService.ManualStart();
1730 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1731 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(nullptr));
1732 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_INVALID_PRINTJOB);
1733 }
1734
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtensionIdNotFound)1735 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtensionIdNotFound)
1736 {
1737 PrintServiceAbility printService;
1738 std::string jobId = "testJobId";
1739 printService.ManualStart();
1740 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1741 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1742 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1743 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1744 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1745 }
1746
TEST_F(nullTest,CancelPrintJob_ShouldReturnServerFailure_WhenExtCallbackNotFound)1747 TEST_F(nullTest, CancelPrintJob_ShouldReturnServerFailure_WhenExtCallbackNotFound)
1748 {
1749 PrintServiceAbility printService;
1750 std::string jobId = "testJobId";
1751 printService.ManualStart();
1752 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1753 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1754 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1755 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1756 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1757 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_SERVER_FAILURE);
1758 }
1759
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtensionIdFound)1760 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtensionIdFound)
1761 {
1762 PrintServiceAbility printService;
1763 std::string jobId = "testJobId";
1764 printService.ManualStart();
1765 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1766 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1767 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1768 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1769 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1770 EXPECT_CALL(printService, extCallbackMap_[_]).WillOnce(Return(nullptr));
1771 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1772 }
1773
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtCallbackFound)1774 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtCallbackFound)
1775 {
1776 PrintServiceAbility printService;
1777 std::string jobId = "testJobId";
1778 printService.ManualStart();
1779 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1780 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1781 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1782 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1783 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1784 EXPECT_CALL(printService, extCallbackMap_[_]).WillOnce(Return(new Callback()));
1785 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1786 }
1787
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtCallbackOnCallbackReturnsFalse)1788 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtCallbackOnCallbackReturnsFalse)
1789 {
1790 PrintServiceAbility printService;
1791 std::string jobId = "testJobId";
1792 printService.ManualStart();
1793 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1794 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1795 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1796 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1797 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1798 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1799 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(true));
1800 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1801 }
1802
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtCallbackOnCallbackReturnsTrue)1803 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsQueuedAndExtCallbackOnCallbackReturnsTrue)
1804 {
1805 PrintServiceAbility printService;
1806 std::string jobId = "testJobId";
1807 printService.ManualStart();
1808 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1809 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1810 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1811 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1812 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1813 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1814 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1815 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(E_PRINT_NONE));
1816 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1817 }
1818
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsOtherThanQueued)1819 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsOtherThanQueued)
1820 {
1821 PrintServiceAbility printService;
1822 std::string jobId = "testJobId";
1823 printService.ManualStart();
1824 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1825 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1826 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1827 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1828 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1829 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1830 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1831 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(E_PRINT_NONE));
1832 EXPECT_CALL(printService, jobIt->second->GetJobState()).WillOnce(Return(PRINT_JOB_PRINTING));
1833 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1834 }
1835
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsPrinting)1836 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsPrinting)
1837 {
1838 PrintServiceAbility printService;
1839 std::string jobId = "testJobId";
1840 printService.ManualStart();
1841 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1842 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1843 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1844 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1845 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1846 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1847 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1848 EXPECT_CALL(printService, serviceHandler_->PostTask(_,)).WillOnce(Return(E_PRINT_NONE));
1849 EXPECT_CALL(printService, jobIt->second->GetJobState()).WillOnce(Return(PRINT_JOB_PRINTING));
1850 EXPECT_CALL(printService, jobIt->second->SetJobState()).WillOnce(Return(E_PRINT_NONE));
1851 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1852 }
1853
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsCompleted)1854 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsCompleted)
1855 {
1856 PrintServiceAbility printService;
1857 std::string jobId = "testJobId";
1858 printService.ManualStart();
1859 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1860 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1861 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1862 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1863 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1864 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1865 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1866 EXPECT_CALL(printService, serviceHandler_->PostTask(_,)).WillOnce(Return(E_PRINT_NONE));
1867 EXPECT_CALL(printService, jobIt->second->GetJobState()).WillOnce(Return(PRINT_JOB_COMPLETED));
1868 EXPECT_CALL(printService, jobIt->second->SetJobState()).WillOnce(Return(E_PRINT_NONE));
1869 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1870 }
1871
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsCancelled)1872 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsCancelled)
1873 {
1874 PrintServiceAbility printService;
1875 std::string jobId = "testJobId";
1876 printService.ManualStart();
1877 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1878 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1879 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1880 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1881 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1882 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1883 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1884 EXPECT_CALL(printService, serviceHandler_->PostTask(_,)).WillOnce(Return(E_PRINT_NONE));
1885 EXPECT_CALL(printService, jobIt->second->GetJobState()).WillOnce(Return(PRINT_JOB_CANCELLED));
1886 EXPECT_CALL(printService, jobIt->second->SetJobState()).WillOnce(Return(E_PRINT_NONE));
1887 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1888 }
1889
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsFailed)1890 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsFailed)
1891 {
1892 PrintServiceAbility printService;
1893 std::string jobId = "testJobId";
1894 printService.ManualStart();
1895 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1896 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1897 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1898 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1899 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1900 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1901 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1902 EXPECT_CALL(printService, serviceHandler_->PostTask(_,)).WillOnce(Return(E_PRINT_NONE));
1903 EXPECT_CALL(printService, jobIt->second->GetJobState()).WillOnce(Return(PRINT_JOB_FAILED));
1904 EXPECT_CALL(printService, jobIt->second->SetJobState()).WillOnce(Return(E_PRINT_NONE));
1905 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1906 }
1907
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsOtherThanFailed)1908 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsOtherThanFailed)
1909 {
1910 PrintServiceAbility printService;
1911 std::string jobId = "testJobId";
1912 printService.ManualStart();
1913 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1914 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1915 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1916 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1917 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1918 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1919 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1920 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(E_PRINT_NONE));
1921 EXPECT_CALL(printService, jobIt->second->GetJobState()).WillOnce(Return(PRINT_JOB_NONE));
1922 EXPECT_CALL(printService, jobIt->second->SetJobState()).WillOnce(Return(E_PRINT_NONE));
1923 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1924 }
1925
TEST_F(nullTest,CancelPrintJob_ShouldReturnNone_WhenJobStateIsNone)1926 TEST_F(nullTest, CancelPrintJob_ShouldReturnNone_WhenJobStateIsNone)
1927 {
1928 PrintServiceAbility printService;
1929 std::string jobId = "testJobId";
1930 printService.ManualStart();
1931 EXPECT_CALL(printService, CheckPermission(PERMISSION_NAME_PRINT_JOB)).WillOnce(Return(true));
1932 EXPECT_CALL(printService, GetUserDataByJobId(jobId)).WillOnce(Return(new UserData()));
1933 EXPECT_CALL(printService, UpdatePrintJobState(jobId, PRINT_JOB_COMPLETED,
1934 PRINT_JOB_COMPLETED_CANCELLED)).WillOnce(Return(E_PRINT_NONE));
1935 EXPECT_CALL(printService, SetPrintJobCanceled(_)).WillOnce(Return(E_PRINT_NONE));
1936 EXPECT_CALL(printService, extCallbackMap_[]).WillOnce(Return(new Callback()));
1937 EXPECT_CALL(printService, helper->IsSyncMode()).WillOnce(Return(false));
1938 EXPECT_CALL(printService, serviceHandler_->PostTask(_, _)).WillOnce(Return(E_PRINT_NONE));
1939 EXPECT_CALL(printService, jobIt->second->GetJobState()).WillOnce(Return(PRINT_JOB_NONE));
1940 EXPECT_CALL(printService, jobIt->second->SetJobState()).WillOnce(Return(E_PRINT_NONE));
1941 EXPECT_EQ(printService.CancelPrintJob(jobId), E_PRINT_NONE);
1942 }
1943
TEST_F(nullTest,SetPrintJobCanceled_Test)1944 TEST_F(nullTest, SetPrintJobCanceled_Test)
1945 {
1946 PrintServiceAbility printServiceAbility;
1947 PrintJob jobInfo;
1948 jobInfo.SetJobId("123");
1949 printServiceAbility.SetPrintJobCanceled(jobInfo);
1950 EXPECT_EQ(jobInfo.GetJobState(), PRINT_JOB_COMPLETED);
1951 EXPECT_EQ(jobInfo.GetSubState(), PRINT_JOB_COMPLETED_CANCELLED);
1952 EXPECT_EQ(printServiceAbility.printJobList_.find("123")->second->GetJobId(), "123");
1953 }
1954
TEST_F(nullTest,SetPrintJobCanceled_NullJobInfo_Test)1955 TEST_F(nullTest, SetPrintJobCanceled_NullJobInfo_Test)
1956 {
1957 PrintServiceAbility printServiceAbility;
1958 PrintJob jobInfo;
1959 printServiceAbility.SetPrintJobCanceled(jobInfo);
1960 EXPECT_EQ(printServiceAbility.GetUserDataByJobId("123"), nullptr);
1961 }
1962
TEST_F(nullTest,SetPrintJobCanceled_NullUserData_Test)1963 TEST_F(nullTest, SetPrintJobCanceled_NullUserData_Test)
1964 {
1965 PrintServiceAbility printServiceAbility;
1966 PrintJob jobInfo;
1967 jobInfo.SetJobId("123");
1968 printServiceAbility.UpdatePrintJobState = [](const std::string&, PrintJobState, PrintJobSubState) {};
1969 printServiceAbility.SetPrintJobCanceled(jobInfo);
1970 EXPECT_EQ(printServiceAbility.printJobList_.find("123")->second->GetJobId(), "123");
1971 }
1972
TEST_F(nullTest,SetPrintJobCanceled_AllNull_Test)1973 TEST_F(nullTest, SetPrintJobCanceled_AllNull_Test)
1974 {
1975 PrintServiceAbility printServiceAbility;
1976 PrintJob jobInfo;
1977 printServiceAbility.UpdatePrintJobState = [](const std::string&, PrintJobState, PrintJobSubState) {};
1978 printServiceAbility.SetPrintJobCanceled(jobInfo);
1979 EXPECT_EQ(printServiceAbility.GetUserDataByJobId("123"), nullptr);
1980 }
1981
1982 } // namespace OHOS::Print