1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "running_lock_mock_test.h"
17
18 #include "mock_lock_action.h"
19 #include "mock_power_action.h"
20 #include "mock_state_action.h"
21 #include "power_common.h"
22 #include "power_mgr_service.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::PowerMgr;
26 using namespace OHOS;
27 using namespace std;
28 using ::testing::_;
29
30 namespace {
31 const std::string RUNNINGLOCK_BACKGROUND_NAME = "OHOS.RunningLock.Background";
32 constexpr int32_t RUNNINGLOCKPARAM_TIMEOUTMS_DEF = -1;
33 } // namespace
34 static sptr<PowerMgrService> g_powerService;
35 static MockStateAction* g_powerStateAction;
36 static MockStateAction* g_shutdownStateAction;
37 static MockPowerAction* g_powerAction;
38 static MockLockAction* g_lockAction;
39
ResetMockAction()40 static void ResetMockAction()
41 {
42 g_powerStateAction = new MockStateAction();
43 g_shutdownStateAction = new MockStateAction();
44 g_powerAction = new MockPowerAction();
45 g_lockAction = new MockLockAction();
46 g_powerService->EnableMock(g_powerStateAction, g_shutdownStateAction, g_powerAction, g_lockAction);
47 }
48
SetUpTestCase(void)49 void RunningLockMockTest::SetUpTestCase(void)
50 {
51 // create singleton service object at the beginning
52 g_powerService = DelayedSpSingleton<PowerMgrService>::GetInstance();
53 g_powerService->OnStart();
54 }
55
TearDownTestCase(void)56 void RunningLockMockTest::TearDownTestCase(void)
57 {
58 g_powerService->OnStop();
59 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
60 }
61
SetUp(void)62 void RunningLockMockTest::SetUp(void)
63 {
64 ResetMockAction();
65 }
66
67 namespace {
68 /**
69 * @tc.name: RunningLockMockTest001
70 * @tc.desc: test proximity screen control runninglock by mock
71 * @tc.type: FUNC
72 * @tc.require: issueI6LPK9
73 */
74 HWTEST_F (RunningLockMockTest, RunningLockMockTest001, TestSize.Level2)
75 {
76 ASSERT_NE(g_powerService, nullptr);
77 ASSERT_NE(g_lockAction, nullptr);
78
79 RunningLockInfo runninglockInfo(
80 "RunningLockMockProximity1.1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
81 RunningLockInfo runninglockInfo2(
82 "RunningLockMockProximity1.2", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
83 int32_t timeoutMs = 100;
84 auto runningLockMgr = g_powerService->GetRunningLockMgr();
85 uint32_t lockActionCount = 0;
86 uint32_t unlockActionCount = 0;
87
__anoncd1def9a0302(const RunningLockParam& param) 88 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
89 EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
90 EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
91 EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
92 lockActionCount++;
93 return RUNNINGLOCK_SUCCESS;
94 });
__anoncd1def9a0402(const RunningLockParam& param) 95 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
96 EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
97 EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
98 unlockActionCount++;
99 return RUNNINGLOCK_SUCCESS;
100 });
101
102 sptr<IRemoteObject> runninglockToken = new RunningLockTokenStub();
103 sptr<IRemoteObject> runninglockToken2 = new RunningLockTokenStub();
104 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken, runninglockInfo));
105 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken2, runninglockInfo2));
106
107 g_powerService->Lock(runninglockToken);
108 EXPECT_EQ(1, runningLockMgr->GetValidRunningLockNum(runninglockInfo.type));
109 g_powerService->Lock(runninglockToken2);
110 EXPECT_EQ(2, runningLockMgr->GetValidRunningLockNum(runninglockInfo2.type));
111
112 g_powerService->UnLock(runninglockToken);
113 EXPECT_EQ(1, runningLockMgr->GetValidRunningLockNum(runninglockInfo.type));
114 g_powerService->UnLock(runninglockToken2);
115 EXPECT_EQ(0, runningLockMgr->GetValidRunningLockNum(runninglockInfo2.type));
116
117 g_powerService->ReleaseRunningLock(runninglockToken);
118 g_powerService->ReleaseRunningLock(runninglockToken2);
119
120 EXPECT_EQ(lockActionCount, 0);
121 EXPECT_EQ(unlockActionCount, 0);
122 }
123
124 /**
125 * @tc.name: RunningLockMockTest002
126 * @tc.desc: test proximity screen control runninglock release function by mock
127 * @tc.type: FUNC
128 * @tc.require: issueI6LPK9
129 */
130 HWTEST_F (RunningLockMockTest, RunningLockMockTest002, TestSize.Level2)
131 {
132 ASSERT_NE(g_powerService, nullptr);
133 ASSERT_NE(g_lockAction, nullptr);
134
135 RunningLockInfo runninglockInfo(
136 "RunningLockMockProximity2.1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
137 int32_t timeoutMs = 100;
138 auto runningLockMgr = g_powerService->GetRunningLockMgr();
139 uint32_t lockActionCount = 0;
140 uint32_t unlockActionCount = 0;
141
__anoncd1def9a0502(const RunningLockParam& param) 142 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
143 EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
144 EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
145 EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
146 lockActionCount++;
147 return RUNNINGLOCK_SUCCESS;
148 });
__anoncd1def9a0602(const RunningLockParam& param) 149 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
150 EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
151 EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
152 unlockActionCount++;
153 return RUNNINGLOCK_SUCCESS;
154 });
155
156 sptr<IRemoteObject> runninglockToken = new RunningLockTokenStub();
157 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken, runninglockInfo));
158
159 g_powerService->Lock(runninglockToken);
160 EXPECT_EQ(1, runningLockMgr->GetValidRunningLockNum(runninglockInfo.type));
161 g_powerService->UnLock(runninglockToken);
162 g_powerService->ReleaseRunningLock(runninglockToken);
163
164 EXPECT_EQ(lockActionCount, 0);
165 EXPECT_EQ(unlockActionCount, 0);
166 }
167
168 /**
169 * @tc.name: RunningLockMockTest003
170 * @tc.desc: test scene runninglock by mock
171 * @tc.type: FUNC
172 * @tc.require: issueI6LPK9
173 */
174 HWTEST_F (RunningLockMockTest, RunningLockMockTest003, TestSize.Level2)
175 {
176 ASSERT_NE(g_powerService, nullptr);
177 ASSERT_NE(g_lockAction, nullptr);
178
179 RunningLockInfo runninglockPhone("RunningLockMockPhone3.1", RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
180 RunningLockInfo runninglockNotify("RunningLockMockNotify3.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION);
181 int32_t timeoutMs = -1;
182 uint32_t lockActionCount = 0;
183 uint32_t unlockActionCount = 0;
184
__anoncd1def9a0702(RunningLockType type) 185 auto GetRunningLockInfo = [&](RunningLockType type) {
186 if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE) {
187 return runninglockPhone;
188 }
189 return runninglockNotify;
190 };
191
__anoncd1def9a0802(const RunningLockParam& param) 192 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
193 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
194 EXPECT_EQ(param.name, runninglockInfo.name);
195 EXPECT_EQ(param.type, runninglockInfo.type);
196 EXPECT_EQ(param.timeoutMs, timeoutMs);
197 lockActionCount++;
198 return RUNNINGLOCK_SUCCESS;
199 });
__anoncd1def9a0902(const RunningLockParam& param) 200 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
201 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
202 EXPECT_EQ(param.name, runninglockInfo.name);
203 EXPECT_EQ(param.type, runninglockInfo.type);
204 unlockActionCount++;
205 return RUNNINGLOCK_SUCCESS;
206 });
207
208 sptr<IRemoteObject> phoneToken = new RunningLockTokenStub();
209 sptr<IRemoteObject> notifyToken = new RunningLockTokenStub();
210 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(phoneToken, runninglockPhone));
211 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(notifyToken, runninglockNotify));
212
213 g_powerService->Lock(phoneToken);
214 g_powerService->Lock(notifyToken);
215 g_powerService->UnLock(phoneToken);
216 g_powerService->UnLock(notifyToken);
217
218 g_powerService->ReleaseRunningLock(phoneToken);
219 g_powerService->ReleaseRunningLock(notifyToken);
220
221 EXPECT_EQ(lockActionCount, 2);
222 EXPECT_EQ(unlockActionCount, 2);
223 }
224
225 /**
226 * @tc.name: RunningLockMockTest004
227 * @tc.desc: test scene runninglock by mock
228 * @tc.type: FUNC
229 * @tc.require: issueI6LPK9
230 */
231 HWTEST_F (RunningLockMockTest, RunningLockMockTest004, TestSize.Level2)
232 {
233 ASSERT_NE(g_powerService, nullptr);
234 ASSERT_NE(g_lockAction, nullptr);
235
236 RunningLockInfo runninglockAudio("RunningLockMockAudio4.1", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
237 RunningLockInfo runninglockSport("RunningLockMockSport4.1", RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT);
238 int32_t timeoutMs = -1;
239 uint32_t lockActionCount = 0;
240 uint32_t unlockActionCount = 0;
241
__anoncd1def9a0a02(RunningLockType type) 242 auto GetRunningLockInfo = [&](RunningLockType type) {
243 if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO) {
244 return runninglockAudio;
245 }
246 return runninglockSport;
247 };
248
__anoncd1def9a0b02(const RunningLockParam& param) 249 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
250 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
251 EXPECT_EQ(param.name, runninglockInfo.name);
252 EXPECT_EQ(param.type, runninglockInfo.type);
253 EXPECT_EQ(param.timeoutMs, timeoutMs);
254 lockActionCount++;
255 return RUNNINGLOCK_SUCCESS;
256 });
__anoncd1def9a0c02(const RunningLockParam& param) 257 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
258 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
259 EXPECT_EQ(param.name, runninglockInfo.name);
260 EXPECT_EQ(param.type, runninglockInfo.type);
261 unlockActionCount++;
262 return RUNNINGLOCK_SUCCESS;
263 });
264
265 sptr<IRemoteObject> audioToken = new RunningLockTokenStub();
266 sptr<IRemoteObject> sportToken = new RunningLockTokenStub();
267 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(audioToken, runninglockAudio));
268 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(sportToken, runninglockSport));
269
270 g_powerService->Lock(audioToken);
271 g_powerService->Lock(sportToken);
272 g_powerService->UnLock(audioToken);
273 g_powerService->UnLock(sportToken);
274
275 g_powerService->ReleaseRunningLock(audioToken);
276 g_powerService->ReleaseRunningLock(sportToken);
277
278 EXPECT_EQ(lockActionCount, 2);
279 EXPECT_EQ(unlockActionCount, 2);
280 }
281
282 /**
283 * @tc.name: RunningLockMockTest005
284 * @tc.desc: test scene runninglock by mock
285 * @tc.type: FUNC
286 * @tc.require: issueI6LPK9
287 */
288 HWTEST_F (RunningLockMockTest, RunningLockMockTest005, TestSize.Level2)
289 {
290 ASSERT_NE(g_powerService, nullptr);
291 ASSERT_NE(g_lockAction, nullptr);
292
293 RunningLockInfo runninglockNavi("RunningLockMockNavi5.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION);
294 RunningLockInfo runninglockTask("RunningLockMockTask5.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
295 int32_t timeoutMs = -1;
296 uint32_t lockActionCount = 0;
297 uint32_t unlockActionCount = 0;
298
__anoncd1def9a0d02(RunningLockType type) 299 auto GetRunningLockInfo = [&](RunningLockType type) {
300 if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION) {
301 return runninglockNavi;
302 }
303 return runninglockTask;
304 };
305
__anoncd1def9a0e02(const RunningLockParam& param) 306 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
307 auto runninglockInfo = GetRunningLockInfo(param.type);
308 EXPECT_EQ(param.name, runninglockInfo.name);
309 EXPECT_EQ(param.type, runninglockInfo.type);
310 EXPECT_EQ(param.timeoutMs, timeoutMs);
311 lockActionCount++;
312 return RUNNINGLOCK_SUCCESS;
313 });
__anoncd1def9a0f02(const RunningLockParam& param) 314 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
315 auto runninglockInfo = GetRunningLockInfo(param.type);
316 EXPECT_EQ(param.name, runninglockInfo.name);
317 EXPECT_EQ(param.type, runninglockInfo.type);
318 unlockActionCount++;
319 return RUNNINGLOCK_SUCCESS;
320 });
321
322 sptr<IRemoteObject> naviToken = new RunningLockTokenStub();
323 sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
324
325 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(naviToken, runninglockNavi));
326 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
327
328 g_powerService->Lock(naviToken);
329 g_powerService->Lock(taskToken);
330 g_powerService->UnLock(naviToken);
331 g_powerService->UnLock(taskToken);
332
333 g_powerService->ReleaseRunningLock(naviToken);
334 g_powerService->ReleaseRunningLock(taskToken);
335
336 EXPECT_EQ(lockActionCount, 2);
337 EXPECT_EQ(unlockActionCount, 2);
338 }
339
340 /**
341 * @tc.name: RunningLockMockTest006
342 * @tc.desc: test scene runninglock release function by mock
343 * @tc.type: FUNC
344 * @tc.require: issueI6LPK9
345 */
346 HWTEST_F (RunningLockMockTest, RunningLockMockTest006, TestSize.Level2)
347 {
348 ASSERT_NE(g_powerService, nullptr);
349 ASSERT_NE(g_lockAction, nullptr);
350
351 RunningLockInfo runninglockPhone("RunningLockMockPhone6.1", RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
352 RunningLockInfo runninglockNotify("RunningLockMockNotify6.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION);
353 RunningLockInfo runninglockAudio("RunningLockMockAudio6.1", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
354 int32_t timeoutMs = 100;
355 uint32_t lockActionCount = 0;
356 uint32_t unlockActionCount = 0;
357
__anoncd1def9a1002(RunningLockType type) 358 auto GetRunningLockInfo = [&](RunningLockType type) {
359 RunningLockInfo lockInfo {};
360 switch (type) {
361 case RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE:
362 return runninglockPhone;
363 case RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION:
364 return runninglockNotify;
365 case RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO:
366 return runninglockAudio;
367 default:
368 return lockInfo;
369 }
370 };
371
__anoncd1def9a1102(const RunningLockParam& param) 372 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
373 lockActionCount++;
374 return RUNNINGLOCK_SUCCESS;
375 });
__anoncd1def9a1202(const RunningLockParam& param) 376 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
377 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
378 EXPECT_EQ(param.name, runninglockInfo.name);
379 EXPECT_EQ(param.type, runninglockInfo.type);
380 unlockActionCount++;
381 return RUNNINGLOCK_SUCCESS;
382 });
383
384 sptr<IRemoteObject> phoneToken = new RunningLockTokenStub();
385 sptr<IRemoteObject> notifyToken = new RunningLockTokenStub();
386 sptr<IRemoteObject> audioToken = new RunningLockTokenStub();
387
388 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(phoneToken, runninglockPhone));
389 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(notifyToken, runninglockNotify));
390 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(audioToken, runninglockAudio));
391
392 g_powerService->Lock(phoneToken);
393 g_powerService->Lock(notifyToken);
394 g_powerService->Lock(audioToken);
395
396 g_powerService->UnLock(phoneToken);
397 g_powerService->UnLock(notifyToken);
398 g_powerService->UnLock(audioToken);
399
400 g_powerService->ReleaseRunningLock(phoneToken);
401 g_powerService->ReleaseRunningLock(notifyToken);
402 g_powerService->ReleaseRunningLock(audioToken);
403
404 EXPECT_EQ(lockActionCount, 3);
405 EXPECT_EQ(unlockActionCount, 3);
406 }
407
408 /**
409 * @tc.name: RunningLockMockTest007
410 * @tc.desc: test scene runninglock release function by mock
411 * @tc.type: FUNC
412 * @tc.require: issueI6LPK9
413 */
414 HWTEST_F (RunningLockMockTest, RunningLockMockTest007, TestSize.Level2)
415 {
416 ASSERT_NE(g_powerService, nullptr);
417 ASSERT_NE(g_lockAction, nullptr);
418
419 RunningLockInfo runninglockSport("RunningLockMockSport7.1", RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT);
420 RunningLockInfo runninglockNavi("RunningLockMockNavi7.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION);
421 RunningLockInfo runninglockTask("RunningLockMockTask7.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
422 int32_t timeoutMs = 100;
423 uint32_t lockActionCount = 0;
424 uint32_t unlockActionCount = 0;
425
__anoncd1def9a1302(RunningLockType type) 426 auto GetRunningLockInfo = [&](RunningLockType type) {
427 RunningLockInfo lockInfo {};
428 switch (type) {
429 case RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT:
430 return runninglockSport;
431 case RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION:
432 return runninglockNavi;
433 case RunningLockType::RUNNINGLOCK_BACKGROUND_TASK:
434 return runninglockTask;
435 default:
436 return lockInfo;
437 }
438 };
439
__anoncd1def9a1402(const RunningLockParam& param) 440 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
441 lockActionCount++;
442 return RUNNINGLOCK_SUCCESS;
443 });
__anoncd1def9a1502(const RunningLockParam& param) 444 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
445 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
446 EXPECT_EQ(param.name, runninglockInfo.name);
447 EXPECT_EQ(param.type, runninglockInfo.type);
448 unlockActionCount++;
449 return RUNNINGLOCK_SUCCESS;
450 });
451
452 sptr<IRemoteObject> sportToken = new RunningLockTokenStub();
453 sptr<IRemoteObject> naviToken = new RunningLockTokenStub();
454 sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
455
456 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(sportToken, runninglockSport));
457 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(naviToken, runninglockNavi));
458 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
459
460 g_powerService->Lock(sportToken);
461 g_powerService->Lock(naviToken);
462 g_powerService->Lock(taskToken);
463
464 g_powerService->UnLock(sportToken);
465 g_powerService->UnLock(naviToken);
466 g_powerService->UnLock(taskToken);
467
468 g_powerService->ReleaseRunningLock(sportToken);
469 g_powerService->ReleaseRunningLock(naviToken);
470 g_powerService->ReleaseRunningLock(taskToken);
471
472 EXPECT_EQ(lockActionCount, 3);
473 EXPECT_EQ(unlockActionCount, 3);
474 }
475
476 /**
477 * @tc.name: RunningLockMockTest008
478 * @tc.desc: Test ProxyRunningLock function, test Background runninglock
479 * @tc.type: FUNC
480 * @tc.require: issueI6S0YY
481 */
482 HWTEST_F (RunningLockMockTest, RunningLockMockTest008, TestSize.Level2)
483 {
484 ASSERT_NE(g_powerService, nullptr);
485 ASSERT_NE(g_lockAction, nullptr);
486
487 RunningLockInfo runninglockInfo("RunningLockMockBackground8.1", RunningLockType::RUNNINGLOCK_BACKGROUND);
488 auto runningLockMgr = g_powerService->GetRunningLockMgr();
489 uint32_t lockActionCount = 0;
490 uint32_t unlockActionCount = 0;
491 pid_t curUid = getuid();
492 pid_t curPid = getpid();
493
__anoncd1def9a1602(const RunningLockParam& param) 494 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
495 EXPECT_EQ(param.name, runninglockInfo.name);
496 EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
497 EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
498 lockActionCount++;
499 return RUNNINGLOCK_SUCCESS;
500 });
__anoncd1def9a1702(const RunningLockParam& param) 501 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
502 EXPECT_EQ(param.name, runninglockInfo.name);
503 EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
504 unlockActionCount++;
505 return RUNNINGLOCK_SUCCESS;
506 });
507
508 sptr<IRemoteObject> runninglockToken = new RunningLockTokenStub();
509 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken, runninglockInfo));
510 auto backgroundLock = runningLockMgr->GetRunningLockInner(runninglockToken);
511 ASSERT_NE(backgroundLock, nullptr);
512 g_powerService->Lock(runninglockToken);
513 EXPECT_TRUE(backgroundLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
514 EXPECT_EQ(lockActionCount, 1);
515
516 EXPECT_TRUE(g_powerService->ProxyRunningLock(true, curPid, curUid));
517
518 EXPECT_TRUE(backgroundLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
519 EXPECT_EQ(unlockActionCount, 1);
520
521 EXPECT_TRUE(g_powerService->ProxyRunningLock(false, curPid, curUid));
522
523 EXPECT_TRUE(backgroundLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
524 EXPECT_EQ(lockActionCount, 2);
525
526 g_powerService->UnLock(runninglockToken);
527 g_powerService->ReleaseRunningLock(runninglockToken);
528 EXPECT_EQ(unlockActionCount, 2);
529 }
530
531 /**
532 * @tc.name: RunningLockMockTest009
533 * @tc.desc: Test ProxyRunningLock function, test Scene runninglock
534 * @tc.type: FUNC
535 * @tc.require: issueI6S0YY
536 */
537 HWTEST_F (RunningLockMockTest, RunningLockMockTest009, TestSize.Level2)
538 {
539 ASSERT_NE(g_powerService, nullptr);
540 ASSERT_NE(g_lockAction, nullptr);
541
542 RunningLockInfo runninglockPhone("RunningLockMockPhone9.1", RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
543 RunningLockInfo runninglockNotify("RunningLockMockNotify9.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION);
544 uint32_t lockActionCount = 0;
545 uint32_t unlockActionCount = 0;
546 pid_t curUid = getuid();
547 pid_t curPid = getpid();
548
__anoncd1def9a1802(RunningLockType type) 549 auto GetRunningLockInfo = [&](RunningLockType type) {
550 if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE) {
551 return runninglockPhone;
552 }
553 return runninglockNotify;
554 };
555
__anoncd1def9a1902(const RunningLockParam& param) 556 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
557 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
558 EXPECT_EQ(param.name, runninglockInfo.name);
559 EXPECT_EQ(param.type, runninglockInfo.type);
560 EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
561 lockActionCount++;
562 return RUNNINGLOCK_SUCCESS;
563 });
__anoncd1def9a1a02(const RunningLockParam& param) 564 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
565 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
566 EXPECT_EQ(param.name, runninglockInfo.name);
567 EXPECT_EQ(param.type, runninglockInfo.type);
568 unlockActionCount++;
569 return RUNNINGLOCK_NOT_SUPPORT;
570 });
571
572 sptr<IRemoteObject> phoneToken = new RunningLockTokenStub();
573 sptr<IRemoteObject> notifyToken = new RunningLockTokenStub();
574 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(phoneToken, runninglockPhone));
575 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(notifyToken, runninglockNotify));
576
577
578 EXPECT_TRUE(g_powerService->ProxyRunningLocks(true, {std::make_pair(curPid, curUid)}));
579 EXPECT_EQ(unlockActionCount, 0);
580
581 g_powerService->Lock(phoneToken);
582 g_powerService->Lock(notifyToken);
583 g_powerService->UnLock(phoneToken);
584 g_powerService->UnLock(notifyToken);
585
586 EXPECT_EQ(lockActionCount, 2);
587 EXPECT_EQ(unlockActionCount, 2);
588
589
590 EXPECT_TRUE(g_powerService->ProxyRunningLocks(false, {std::make_pair(curPid, curUid)}));
591 EXPECT_EQ(lockActionCount, 2);
592
593 g_powerService->ReleaseRunningLock(phoneToken);
594 g_powerService->ReleaseRunningLock(notifyToken);
595 }
596
597 /**
598 * @tc.name: RunningLockMockTest010
599 * @tc.desc: Test ProxyRunningLock function, test Scene runninglock
600 * @tc.type: FUNC
601 * @tc.require: issueI6S0YY
602 */
603 HWTEST_F (RunningLockMockTest, RunningLockMockTest010, TestSize.Level2)
604 {
605 ASSERT_NE(g_powerService, nullptr);
606 ASSERT_NE(g_lockAction, nullptr);
607
608 RunningLockInfo runninglockAudio("RunningLockMockAudio10.1", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
609 RunningLockInfo runninglockSport("RunningLockMockSport10.1", RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT);
610 auto runningLockMgr = g_powerService->GetRunningLockMgr();
611 uint32_t lockActionCount = 0;
612 uint32_t unlockActionCount = 0;
613
__anoncd1def9a1b02(RunningLockType type) 614 auto GetRunningLockInfo = [&](RunningLockType type) {
615 return type == RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO ? runninglockAudio : runninglockSport;
616 };
617
__anoncd1def9a1c02(const RunningLockParam& param) 618 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
619 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
620 EXPECT_EQ(param.name, runninglockInfo.name);
621 EXPECT_EQ(param.type, runninglockInfo.type);
622 EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
623 lockActionCount++;
624 return RUNNINGLOCK_SUCCESS;
625 });
__anoncd1def9a1d02(const RunningLockParam& param) 626 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
627 RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
628 EXPECT_EQ(param.name, runninglockInfo.name);
629 EXPECT_EQ(param.type, runninglockInfo.type);
630 unlockActionCount++;
631 return RUNNINGLOCK_SUCCESS;
632 });
633
634 sptr<IRemoteObject> audioToken = new RunningLockTokenStub();
635 sptr<IRemoteObject> sportToken = new RunningLockTokenStub();
636 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(audioToken, runninglockAudio));
637 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(sportToken, runninglockSport));
638 auto audioLock = runningLockMgr->GetRunningLockInner(audioToken);
639 auto sportLock = runningLockMgr->GetRunningLockInner(sportToken);
640
641 g_powerService->Lock(audioToken);
642 g_powerService->Lock(sportToken);
643 EXPECT_EQ(lockActionCount, 2);
644 EXPECT_TRUE(audioLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
645 EXPECT_TRUE(sportLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
646
647 EXPECT_TRUE(g_powerService->ProxyRunningLock(true, getpid(), getuid()));
648
649 EXPECT_EQ(unlockActionCount, 2);
650 EXPECT_TRUE(audioLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
651 EXPECT_TRUE(sportLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
652
653 EXPECT_TRUE(g_powerService->ProxyRunningLock(false, getpid(), getuid()));
654
655 EXPECT_EQ(lockActionCount, 4);
656 EXPECT_TRUE(audioLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
657 EXPECT_TRUE(sportLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
658
659 g_powerService->UnLock(audioToken);
660 g_powerService->UnLock(sportToken);
661 g_powerService->ReleaseRunningLock(audioToken);
662 g_powerService->ReleaseRunningLock(sportToken);
663 }
664
665 /**
666 * @tc.name: RunningLockMockTest011
667 * @tc.desc: Test ProxyRunningLock function, test Scene runninglock, HDI unlock() return RUNNINGLOCK_NOT_SUPPORT
668 * @tc.type: FUNC
669 * @tc.require: issueI6S0YY
670 */
671 HWTEST_F (RunningLockMockTest, RunningLockMockTest011, TestSize.Level2)
672 {
673 ASSERT_NE(g_powerService, nullptr);
674 ASSERT_NE(g_lockAction, nullptr);
675
676 RunningLockInfo runninglockNavi("RunningLockMockNavi11.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION);
677 auto runningLockMgr = g_powerService->GetRunningLockMgr();
678 uint32_t lockActionCount = 0;
679 uint32_t unlockActionCount = 0;
680 int32_t timeoutMs = -1;
681 pid_t curUid = getuid();
682 pid_t curPid = getpid();
683
__anoncd1def9a1e02(const RunningLockParam& param) 684 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
685 EXPECT_EQ(param.name, runninglockNavi.name);
686 EXPECT_EQ(param.type, runninglockNavi.type);
687 EXPECT_EQ(param.timeoutMs, timeoutMs);
688 lockActionCount++;
689 return RUNNINGLOCK_SUCCESS;
690 });
__anoncd1def9a1f02(const RunningLockParam& param) 691 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
692 EXPECT_EQ(param.name, runninglockNavi.name);
693 EXPECT_EQ(param.type, runninglockNavi.type);
694 unlockActionCount++;
695 return RUNNINGLOCK_NOT_SUPPORT;
696 });
697
698 sptr<IRemoteObject> naviToken = new RunningLockTokenStub();
699 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(naviToken, runninglockNavi));
700 auto naviLock = runningLockMgr->GetRunningLockInner(naviToken);
701
702 g_powerService->Lock(naviToken);
703 EXPECT_EQ(lockActionCount, 1);
704 EXPECT_TRUE(naviLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
705
706 EXPECT_TRUE(g_powerService->ProxyRunningLock(true, curPid, curUid));
707
708 EXPECT_EQ(unlockActionCount, 1);
709 EXPECT_TRUE(naviLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
710
711 EXPECT_TRUE(g_powerService->ProxyRunningLock(false, curPid, curUid));
712
713 EXPECT_EQ(lockActionCount, 1);
714 EXPECT_TRUE(naviLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
715
716 g_powerService->UnLock(naviToken);
717 g_powerService->ReleaseRunningLock(naviToken);
718 }
719
720 /**
721 * @tc.name: RunningLockMockTest012
722 * @tc.desc: Test ProxyRunningLock function, test Scene runninglock, HDI unlock() return RUNNINGLOCK_SUCCESS
723 * @tc.type: FUNC
724 * @tc.require: issueI6S0YY
725 */
726 HWTEST_F (RunningLockMockTest, RunningLockMockTest012, TestSize.Level2)
727 {
728 ASSERT_NE(g_powerService, nullptr);
729 ASSERT_NE(g_lockAction, nullptr);
730
731 RunningLockInfo runninglockTask("RunningLockMockTask12.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
732 auto runningLockMgr = g_powerService->GetRunningLockMgr();
733 uint32_t lockActionCount = 0;
734 uint32_t unlockActionCount = 0;
735 int32_t timeoutMs = -1;
736 pid_t curUid = getuid();
737 pid_t curPid = getpid();
738
__anoncd1def9a2002(const RunningLockParam& param) 739 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
740 EXPECT_EQ(param.name, runninglockTask.name);
741 EXPECT_EQ(param.type, runninglockTask.type);
742 EXPECT_EQ(param.timeoutMs, timeoutMs);
743 lockActionCount++;
744 return RUNNINGLOCK_SUCCESS;
745 });
__anoncd1def9a2102(const RunningLockParam& param) 746 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
747 EXPECT_EQ(param.name, runninglockTask.name);
748 EXPECT_EQ(param.type, runninglockTask.type);
749 unlockActionCount++;
750 return RUNNINGLOCK_SUCCESS;
751 });
752
753 sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
754 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
755 auto taskLock = runningLockMgr->GetRunningLockInner(taskToken);
756
757 g_powerService->Lock(taskToken);
758 EXPECT_EQ(lockActionCount, 1);
759 EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
760
761
762 EXPECT_TRUE(g_powerService->ProxyRunningLocks(true, {std::make_pair(curPid, curUid)}));
763 EXPECT_EQ(unlockActionCount, 1);
764 EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
765
766
767 EXPECT_TRUE(g_powerService->ProxyRunningLocks(false, {std::make_pair(curPid, curUid)}));
768 EXPECT_EQ(lockActionCount, 2);
769 EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
770
771 g_powerService->UnLock(taskToken);
772 g_powerService->ReleaseRunningLock(taskToken);
773 }
774
775 /**
776 * @tc.name: RunningLockMockTest013
777 * @tc.desc: Test ProxyRunningLock function, runninglock release first, then cancel the proxy
778 * @tc.type: FUNC
779 * @tc.require: issueI6TW2R
780 */
781 HWTEST_F (RunningLockMockTest, RunningLockMockTest013, TestSize.Level2)
782 {
783 ASSERT_NE(g_powerService, nullptr);
784 ASSERT_NE(g_lockAction, nullptr);
785
786 RunningLockInfo runninglockTask("RunningLockMockTask13.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
787 auto runningLockMgr = g_powerService->GetRunningLockMgr();
788 uint32_t lockActionCount = 0;
789 uint32_t unlockActionCount = 0;
790 int32_t timeoutMs = -1;
791 pid_t curUid = getuid();
792 pid_t curPid = getpid();
793
__anoncd1def9a2202(const RunningLockParam& param) 794 EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
795 EXPECT_EQ(param.name, runninglockTask.name);
796 EXPECT_EQ(param.type, runninglockTask.type);
797 EXPECT_EQ(param.timeoutMs, timeoutMs);
798 lockActionCount++;
799 return RUNNINGLOCK_SUCCESS;
800 });
__anoncd1def9a2302(const RunningLockParam& param) 801 EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
802 EXPECT_EQ(param.name, runninglockTask.name);
803 EXPECT_EQ(param.type, runninglockTask.type);
804 unlockActionCount++;
805 return RUNNINGLOCK_SUCCESS;
806 });
807
808 sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
809 EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
810 auto taskLock = runningLockMgr->GetRunningLockInner(taskToken);
811
812 g_powerService->Lock(taskToken);
813 EXPECT_EQ(lockActionCount, 1);
814 EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
815
816 EXPECT_TRUE(g_powerService->ProxyRunningLock(true, curPid, curUid));
817
818 EXPECT_EQ(unlockActionCount, 1);
819 EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
820
821 g_powerService->UnLock(taskToken);
822 g_powerService->ReleaseRunningLock(taskToken);
823 EXPECT_EQ(runningLockMgr->GetRunningLockInner(taskToken), nullptr);
824
825 EXPECT_TRUE(g_powerService->ProxyRunningLock(false, curPid, curUid));
826
827 EXPECT_EQ(lockActionCount, 1);
828 }
829 }
830