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