1 /*
2  * Copyright (c) 2023-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 "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  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest001, TestSize.Level2)74 HWTEST_F (RunningLockMockTest, RunningLockMockTest001, TestSize.Level2)
75 {
76     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest001 start.");
77     ASSERT_NE(g_powerService, nullptr);
78     ASSERT_NE(g_lockAction, nullptr);
79 
80     RunningLockInfo runninglockInfo(
81         "RunningLockMockProximity1.1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
82     RunningLockInfo runninglockInfo2(
83         "RunningLockMockProximity1.2", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
84     int32_t timeoutMs = 100;
85     auto runningLockMgr = g_powerService->GetRunningLockMgr();
86     uint32_t lockActionCount = 0;
87     uint32_t unlockActionCount = 0;
88 
89     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
90             EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
91             EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
92             EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
93             lockActionCount++;
94             return RUNNINGLOCK_SUCCESS;
95         });
96     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
97             EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
98             EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
99             unlockActionCount++;
100             return RUNNINGLOCK_SUCCESS;
101         });
102 
103     sptr<IRemoteObject> runninglockToken = new RunningLockTokenStub();
104     sptr<IRemoteObject> runninglockToken2 = new RunningLockTokenStub();
105     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken, runninglockInfo));
106     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken2, runninglockInfo2));
107 
108     g_powerService->Lock(runninglockToken);
109     EXPECT_EQ(1, runningLockMgr->GetValidRunningLockNum(runninglockInfo.type));
110     g_powerService->Lock(runninglockToken2);
111     EXPECT_EQ(2, runningLockMgr->GetValidRunningLockNum(runninglockInfo2.type));
112 
113     g_powerService->UnLock(runninglockToken);
114     EXPECT_EQ(1, runningLockMgr->GetValidRunningLockNum(runninglockInfo.type));
115     g_powerService->UnLock(runninglockToken2);
116     EXPECT_EQ(0, runningLockMgr->GetValidRunningLockNum(runninglockInfo2.type));
117 
118     g_powerService->ReleaseRunningLock(runninglockToken);
119     g_powerService->ReleaseRunningLock(runninglockToken2);
120 
121     EXPECT_EQ(lockActionCount, 0);
122     EXPECT_EQ(unlockActionCount, 0);
123     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest001 end.");
124 }
125 
126 /**
127  * @tc.name: RunningLockMockTest002
128  * @tc.desc: test proximity screen control runninglock release function by mock
129  * @tc.type: FUNC
130  * @tc.require: issueI6LPK9
131  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest002, TestSize.Level2)132 HWTEST_F (RunningLockMockTest, RunningLockMockTest002, TestSize.Level2)
133 {
134     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest002 start.");
135     ASSERT_NE(g_powerService, nullptr);
136     ASSERT_NE(g_lockAction, nullptr);
137 
138     RunningLockInfo runninglockInfo(
139         "RunningLockMockProximity2.1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
140     int32_t timeoutMs = 100;
141     auto runningLockMgr = g_powerService->GetRunningLockMgr();
142     uint32_t lockActionCount = 0;
143     uint32_t unlockActionCount = 0;
144 
145     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
146             EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
147             EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
148             EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
149             lockActionCount++;
150             return RUNNINGLOCK_SUCCESS;
151         });
152     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
153             EXPECT_EQ(param.name, RUNNINGLOCK_BACKGROUND_NAME);
154             EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND);
155             unlockActionCount++;
156             return RUNNINGLOCK_SUCCESS;
157         });
158 
159     sptr<IRemoteObject> runninglockToken = new RunningLockTokenStub();
160     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken, runninglockInfo));
161 
162     g_powerService->Lock(runninglockToken);
163     EXPECT_EQ(1, runningLockMgr->GetValidRunningLockNum(runninglockInfo.type));
164     g_powerService->UnLock(runninglockToken);
165     g_powerService->ReleaseRunningLock(runninglockToken);
166 
167     EXPECT_EQ(lockActionCount, 0);
168     EXPECT_EQ(unlockActionCount, 0);
169     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest002 end.");
170 }
171 
172 /**
173  * @tc.name: RunningLockMockTest003
174  * @tc.desc: test scene runninglock by mock
175  * @tc.type: FUNC
176  * @tc.require: issueI6LPK9
177  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest003, TestSize.Level2)178 HWTEST_F (RunningLockMockTest, RunningLockMockTest003, TestSize.Level2)
179 {
180     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest003 start.");
181     ASSERT_NE(g_powerService, nullptr);
182     ASSERT_NE(g_lockAction, nullptr);
183 
184     RunningLockInfo runninglockPhone("RunningLockMockPhone3.1", RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
185     RunningLockInfo runninglockNotify("RunningLockMockNotify3.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION);
186     int32_t timeoutMs = -1;
187     uint32_t lockActionCount = 0;
188     uint32_t unlockActionCount = 0;
189 
190     auto GetRunningLockInfo = [&](RunningLockType type) {
191         if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE) {
192             return runninglockPhone;
193         }
194         return runninglockNotify;
195     };
196 
197     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
198             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
199             EXPECT_EQ(param.name, runninglockInfo.name);
200             EXPECT_EQ(param.type, runninglockInfo.type);
201             EXPECT_EQ(param.timeoutMs, timeoutMs);
202             lockActionCount++;
203             return RUNNINGLOCK_SUCCESS;
204         });
205     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
206             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
207             EXPECT_EQ(param.name, runninglockInfo.name);
208             EXPECT_EQ(param.type, runninglockInfo.type);
209             unlockActionCount++;
210             return RUNNINGLOCK_SUCCESS;
211         });
212 
213     sptr<IRemoteObject> phoneToken = new RunningLockTokenStub();
214     sptr<IRemoteObject> notifyToken = new RunningLockTokenStub();
215     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(phoneToken, runninglockPhone));
216     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(notifyToken, runninglockNotify));
217 
218     g_powerService->Lock(phoneToken);
219     g_powerService->Lock(notifyToken);
220     g_powerService->UnLock(phoneToken);
221     g_powerService->UnLock(notifyToken);
222 
223     g_powerService->ReleaseRunningLock(phoneToken);
224     g_powerService->ReleaseRunningLock(notifyToken);
225 
226     EXPECT_EQ(lockActionCount, 2);
227     EXPECT_EQ(unlockActionCount, 2);
228     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest003 end.");
229 }
230 
231 /**
232  * @tc.name: RunningLockMockTest004
233  * @tc.desc: test scene runninglock by mock
234  * @tc.type: FUNC
235  * @tc.require: issueI6LPK9
236  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest004, TestSize.Level2)237 HWTEST_F (RunningLockMockTest, RunningLockMockTest004, TestSize.Level2)
238 {
239     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest004 start.");
240     ASSERT_NE(g_powerService, nullptr);
241     ASSERT_NE(g_lockAction, nullptr);
242 
243     RunningLockInfo runninglockAudio("RunningLockMockAudio4.1", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
244     RunningLockInfo runninglockSport("RunningLockMockSport4.1", RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT);
245     int32_t timeoutMs = -1;
246     uint32_t lockActionCount = 0;
247     uint32_t unlockActionCount = 0;
248 
249     auto GetRunningLockInfo = [&](RunningLockType type) {
250         if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO) {
251             return runninglockAudio;
252         }
253         return runninglockSport;
254     };
255 
256     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
257             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
258             EXPECT_EQ(param.name, runninglockInfo.name);
259             EXPECT_EQ(param.type, runninglockInfo.type);
260             EXPECT_EQ(param.timeoutMs, timeoutMs);
261             lockActionCount++;
262             return RUNNINGLOCK_SUCCESS;
263         });
264     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
265             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
266             EXPECT_EQ(param.name, runninglockInfo.name);
267             EXPECT_EQ(param.type, runninglockInfo.type);
268             unlockActionCount++;
269             return RUNNINGLOCK_SUCCESS;
270         });
271 
272     sptr<IRemoteObject> audioToken = new RunningLockTokenStub();
273     sptr<IRemoteObject> sportToken = new RunningLockTokenStub();
274     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(audioToken, runninglockAudio));
275     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(sportToken, runninglockSport));
276 
277     g_powerService->Lock(audioToken);
278     g_powerService->Lock(sportToken);
279     g_powerService->UnLock(audioToken);
280     g_powerService->UnLock(sportToken);
281 
282     g_powerService->ReleaseRunningLock(audioToken);
283     g_powerService->ReleaseRunningLock(sportToken);
284 
285     EXPECT_EQ(lockActionCount, 2);
286     EXPECT_EQ(unlockActionCount, 2);
287     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest004 end.");
288 }
289 
290 /**
291  * @tc.name: RunningLockMockTest005
292  * @tc.desc: test scene runninglock by mock
293  * @tc.type: FUNC
294  * @tc.require: issueI6LPK9
295  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest005, TestSize.Level2)296 HWTEST_F (RunningLockMockTest, RunningLockMockTest005, TestSize.Level2)
297 {
298     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest005 start.");
299     ASSERT_NE(g_powerService, nullptr);
300     ASSERT_NE(g_lockAction, nullptr);
301 
302     RunningLockInfo runninglockNavi("RunningLockMockNavi5.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION);
303     RunningLockInfo runninglockTask("RunningLockMockTask5.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
304     int32_t timeoutMs = -1;
305     uint32_t lockActionCount = 0;
306     uint32_t unlockActionCount = 0;
307 
308     auto GetRunningLockInfo = [&](RunningLockType type) {
309         if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION) {
310             return runninglockNavi;
311         }
312         return runninglockTask;
313     };
314 
315     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
316             auto runninglockInfo = GetRunningLockInfo(param.type);
317             EXPECT_EQ(param.name, runninglockInfo.name);
318             EXPECT_EQ(param.type, runninglockInfo.type);
319             EXPECT_EQ(param.timeoutMs, timeoutMs);
320             lockActionCount++;
321             return RUNNINGLOCK_SUCCESS;
322         });
323     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
324             auto runninglockInfo = GetRunningLockInfo(param.type);
325             EXPECT_EQ(param.name, runninglockInfo.name);
326             EXPECT_EQ(param.type, runninglockInfo.type);
327             unlockActionCount++;
328             return RUNNINGLOCK_SUCCESS;
329         });
330 
331     sptr<IRemoteObject> naviToken = new RunningLockTokenStub();
332     sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
333 
334     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(naviToken, runninglockNavi));
335     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
336 
337     g_powerService->Lock(naviToken);
338     g_powerService->Lock(taskToken);
339     g_powerService->UnLock(naviToken);
340     g_powerService->UnLock(taskToken);
341 
342     g_powerService->ReleaseRunningLock(naviToken);
343     g_powerService->ReleaseRunningLock(taskToken);
344 
345     EXPECT_EQ(lockActionCount, 2);
346     EXPECT_EQ(unlockActionCount, 2);
347     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest005 end.");
348 }
349 
350 /**
351  * @tc.name: RunningLockMockTest006
352  * @tc.desc: test scene runninglock release function by mock
353  * @tc.type: FUNC
354  * @tc.require: issueI6LPK9
355  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest006, TestSize.Level2)356 HWTEST_F (RunningLockMockTest, RunningLockMockTest006, TestSize.Level2)
357 {
358     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest006 start.");
359     ASSERT_NE(g_powerService, nullptr);
360     ASSERT_NE(g_lockAction, nullptr);
361 
362     RunningLockInfo runninglockPhone("RunningLockMockPhone6.1", RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
363     RunningLockInfo runninglockNotify("RunningLockMockNotify6.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION);
364     RunningLockInfo runninglockAudio("RunningLockMockAudio6.1", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
365     int32_t timeoutMs = 100;
366     uint32_t lockActionCount = 0;
367     uint32_t unlockActionCount = 0;
368 
369     auto GetRunningLockInfo = [&](RunningLockType type) {
370         RunningLockInfo lockInfo {};
371         switch (type) {
372             case RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE:
373                 return runninglockPhone;
374             case RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION:
375                 return runninglockNotify;
376             case RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO:
377                 return runninglockAudio;
378             default:
379                 return lockInfo;
380         }
381     };
382 
383     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
384             lockActionCount++;
385             return RUNNINGLOCK_SUCCESS;
386         });
387     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
388             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
389             EXPECT_EQ(param.name, runninglockInfo.name);
390             EXPECT_EQ(param.type, runninglockInfo.type);
391             unlockActionCount++;
392             return RUNNINGLOCK_SUCCESS;
393         });
394 
395     sptr<IRemoteObject> phoneToken = new RunningLockTokenStub();
396     sptr<IRemoteObject> notifyToken = new RunningLockTokenStub();
397     sptr<IRemoteObject> audioToken = new RunningLockTokenStub();
398 
399     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(phoneToken, runninglockPhone));
400     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(notifyToken, runninglockNotify));
401     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(audioToken, runninglockAudio));
402 
403     g_powerService->Lock(phoneToken);
404     g_powerService->Lock(notifyToken);
405     g_powerService->Lock(audioToken);
406 
407     g_powerService->UnLock(phoneToken);
408     g_powerService->UnLock(notifyToken);
409     g_powerService->UnLock(audioToken);
410 
411     g_powerService->ReleaseRunningLock(phoneToken);
412     g_powerService->ReleaseRunningLock(notifyToken);
413     g_powerService->ReleaseRunningLock(audioToken);
414 
415     EXPECT_EQ(lockActionCount, 3);
416     EXPECT_EQ(unlockActionCount, 3);
417     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest006 end.");
418 }
419 
420 /**
421  * @tc.name: RunningLockMockTest007
422  * @tc.desc: test scene runninglock release function by mock
423  * @tc.type: FUNC
424  * @tc.require: issueI6LPK9
425  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest007, TestSize.Level2)426 HWTEST_F (RunningLockMockTest, RunningLockMockTest007, TestSize.Level2)
427 {
428     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest007 start.");
429     ASSERT_NE(g_powerService, nullptr);
430     ASSERT_NE(g_lockAction, nullptr);
431 
432     RunningLockInfo runninglockSport("RunningLockMockSport7.1", RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT);
433     RunningLockInfo runninglockNavi("RunningLockMockNavi7.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION);
434     RunningLockInfo runninglockTask("RunningLockMockTask7.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
435     int32_t timeoutMs = 100;
436     uint32_t lockActionCount = 0;
437     uint32_t unlockActionCount = 0;
438 
439     auto GetRunningLockInfo = [&](RunningLockType type) {
440         RunningLockInfo lockInfo {};
441         switch (type) {
442             case RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT:
443                 return runninglockSport;
444             case RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION:
445                 return runninglockNavi;
446             case RunningLockType::RUNNINGLOCK_BACKGROUND_TASK:
447                 return runninglockTask;
448             default:
449                 return lockInfo;
450         }
451     };
452 
453     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
454             lockActionCount++;
455             return RUNNINGLOCK_SUCCESS;
456         });
457     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
458             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
459             EXPECT_EQ(param.name, runninglockInfo.name);
460             EXPECT_EQ(param.type, runninglockInfo.type);
461             unlockActionCount++;
462             return RUNNINGLOCK_SUCCESS;
463         });
464 
465     sptr<IRemoteObject> sportToken = new RunningLockTokenStub();
466     sptr<IRemoteObject> naviToken = new RunningLockTokenStub();
467     sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
468 
469     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(sportToken, runninglockSport));
470     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(naviToken, runninglockNavi));
471     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
472 
473     g_powerService->Lock(sportToken);
474     g_powerService->Lock(naviToken);
475     g_powerService->Lock(taskToken);
476 
477     g_powerService->UnLock(sportToken);
478     g_powerService->UnLock(naviToken);
479     g_powerService->UnLock(taskToken);
480 
481     g_powerService->ReleaseRunningLock(sportToken);
482     g_powerService->ReleaseRunningLock(naviToken);
483     g_powerService->ReleaseRunningLock(taskToken);
484 
485     EXPECT_EQ(lockActionCount, 3);
486     EXPECT_EQ(unlockActionCount, 3);
487     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest007 end.");
488 }
489 
490 /**
491  * @tc.name: RunningLockMockTest008
492  * @tc.desc: Test ProxyRunningLock function, test Background runninglock
493  * @tc.type: FUNC
494  * @tc.require: issueI6S0YY
495  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest008, TestSize.Level2)496 HWTEST_F (RunningLockMockTest, RunningLockMockTest008, TestSize.Level2)
497 {
498     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest008 start.");
499     ASSERT_NE(g_powerService, nullptr);
500     ASSERT_NE(g_lockAction, nullptr);
501 
502     RunningLockInfo runninglockInfo("RunningLockMockBackground8.1", RunningLockType::RUNNINGLOCK_BACKGROUND);
503     auto runningLockMgr = g_powerService->GetRunningLockMgr();
504     uint32_t lockActionCount = 0;
505     uint32_t unlockActionCount = 0;
506     pid_t curUid = getuid();
507     pid_t curPid = getpid();
508 
509     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
510             EXPECT_EQ(param.name, runninglockInfo.name);
511             EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
512             EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
513             lockActionCount++;
514             return RUNNINGLOCK_SUCCESS;
515         });
516     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
517             EXPECT_EQ(param.name, runninglockInfo.name);
518             EXPECT_EQ(param.type, RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
519             unlockActionCount++;
520             return RUNNINGLOCK_SUCCESS;
521         });
522 
523     sptr<IRemoteObject> runninglockToken = new RunningLockTokenStub();
524     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(runninglockToken, runninglockInfo));
525     auto backgroundLock = runningLockMgr->GetRunningLockInner(runninglockToken);
526     ASSERT_NE(backgroundLock, nullptr);
527     g_powerService->Lock(runninglockToken);
528     EXPECT_TRUE(backgroundLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
529     EXPECT_EQ(lockActionCount, 1);
530 
531     EXPECT_TRUE(g_powerService->ProxyRunningLock(true, curPid, curUid));
532 
533     EXPECT_TRUE(backgroundLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
534     EXPECT_EQ(unlockActionCount, 1);
535 
536     EXPECT_TRUE(g_powerService->ProxyRunningLock(false, curPid, curUid));
537 
538     EXPECT_TRUE(backgroundLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
539     EXPECT_EQ(lockActionCount, 2);
540 
541     g_powerService->UnLock(runninglockToken);
542     g_powerService->ReleaseRunningLock(runninglockToken);
543     EXPECT_EQ(unlockActionCount, 2);
544     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest008 end.");
545 }
546 
547 /**
548  * @tc.name: RunningLockMockTest009
549  * @tc.desc: Test ProxyRunningLock function, test Scene runninglock
550  * @tc.type: FUNC
551  * @tc.require: issueI6S0YY
552  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest009, TestSize.Level2)553 HWTEST_F (RunningLockMockTest, RunningLockMockTest009, TestSize.Level2)
554 {
555     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest009 start.");
556     ASSERT_NE(g_powerService, nullptr);
557     ASSERT_NE(g_lockAction, nullptr);
558 
559     RunningLockInfo runninglockPhone("RunningLockMockPhone9.1", RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
560     RunningLockInfo runninglockNotify("RunningLockMockNotify9.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION);
561     uint32_t lockActionCount = 0;
562     uint32_t unlockActionCount = 0;
563     pid_t curUid = getuid();
564     pid_t curPid = getpid();
565 
566     auto GetRunningLockInfo = [&](RunningLockType type) {
567         if (type == RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE) {
568             return runninglockPhone;
569         }
570         return runninglockNotify;
571     };
572 
573     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
574             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
575             EXPECT_EQ(param.name, runninglockInfo.name);
576             EXPECT_EQ(param.type, runninglockInfo.type);
577             EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
578             lockActionCount++;
579             return RUNNINGLOCK_SUCCESS;
580         });
581     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
582             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
583             EXPECT_EQ(param.name, runninglockInfo.name);
584             EXPECT_EQ(param.type, runninglockInfo.type);
585             unlockActionCount++;
586             return RUNNINGLOCK_NOT_SUPPORT;
587         });
588 
589     sptr<IRemoteObject> phoneToken = new RunningLockTokenStub();
590     sptr<IRemoteObject> notifyToken = new RunningLockTokenStub();
591     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(phoneToken, runninglockPhone));
592     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(notifyToken, runninglockNotify));
593 
594 
595     EXPECT_TRUE(g_powerService->ProxyRunningLocks(true, {std::make_pair(curPid, curUid)}));
596     EXPECT_EQ(unlockActionCount, 0);
597 
598     g_powerService->Lock(phoneToken);
599     g_powerService->Lock(notifyToken);
600     g_powerService->UnLock(phoneToken);
601     g_powerService->UnLock(notifyToken);
602 
603     EXPECT_EQ(lockActionCount, 2);
604     EXPECT_EQ(unlockActionCount, 2);
605 
606 
607     EXPECT_TRUE(g_powerService->ProxyRunningLocks(false, {std::make_pair(curPid, curUid)}));
608     EXPECT_EQ(lockActionCount, 2);
609 
610     g_powerService->ReleaseRunningLock(phoneToken);
611     g_powerService->ReleaseRunningLock(notifyToken);
612     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest009 end.");
613 }
614 
615 /**
616  * @tc.name: RunningLockMockTest010
617  * @tc.desc: Test ProxyRunningLock function, test Scene runninglock
618  * @tc.type: FUNC
619  * @tc.require: issueI6S0YY
620  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest010, TestSize.Level2)621 HWTEST_F (RunningLockMockTest, RunningLockMockTest010, TestSize.Level2)
622 {
623     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest010 start.");
624     ASSERT_NE(g_powerService, nullptr);
625     ASSERT_NE(g_lockAction, nullptr);
626 
627     RunningLockInfo runninglockAudio("RunningLockMockAudio10.1", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
628     RunningLockInfo runninglockSport("RunningLockMockSport10.1", RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT);
629     auto runningLockMgr = g_powerService->GetRunningLockMgr();
630     uint32_t lockActionCount = 0;
631     uint32_t unlockActionCount = 0;
632 
633     auto GetRunningLockInfo = [&](RunningLockType type) {
634         return type == RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO ? runninglockAudio : runninglockSport;
635     };
636 
637     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
638             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
639             EXPECT_EQ(param.name, runninglockInfo.name);
640             EXPECT_EQ(param.type, runninglockInfo.type);
641             EXPECT_EQ(param.timeoutMs, RUNNINGLOCKPARAM_TIMEOUTMS_DEF);
642             lockActionCount++;
643             return RUNNINGLOCK_SUCCESS;
644         });
645     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
646             RunningLockInfo runninglockInfo = GetRunningLockInfo(param.type);
647             EXPECT_EQ(param.name, runninglockInfo.name);
648             EXPECT_EQ(param.type, runninglockInfo.type);
649             unlockActionCount++;
650             return RUNNINGLOCK_SUCCESS;
651         });
652 
653     sptr<IRemoteObject> audioToken = new RunningLockTokenStub();
654     sptr<IRemoteObject> sportToken = new RunningLockTokenStub();
655     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(audioToken, runninglockAudio));
656     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(sportToken, runninglockSport));
657     auto audioLock = runningLockMgr->GetRunningLockInner(audioToken);
658     auto sportLock = runningLockMgr->GetRunningLockInner(sportToken);
659 
660     g_powerService->Lock(audioToken);
661     g_powerService->Lock(sportToken);
662     EXPECT_EQ(lockActionCount, 2);
663     EXPECT_TRUE(audioLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
664     EXPECT_TRUE(sportLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
665 
666     EXPECT_TRUE(g_powerService->ProxyRunningLock(true, getpid(), getuid()));
667 
668     EXPECT_EQ(unlockActionCount, 2);
669     EXPECT_TRUE(audioLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
670     EXPECT_TRUE(sportLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
671 
672     EXPECT_TRUE(g_powerService->ProxyRunningLock(false, getpid(), getuid()));
673 
674     EXPECT_EQ(lockActionCount, 4);
675     EXPECT_TRUE(audioLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
676     EXPECT_TRUE(sportLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
677 
678     g_powerService->UnLock(audioToken);
679     g_powerService->UnLock(sportToken);
680     g_powerService->ReleaseRunningLock(audioToken);
681     g_powerService->ReleaseRunningLock(sportToken);
682     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest010 end.");
683 }
684 
685 /**
686  * @tc.name: RunningLockMockTest011
687  * @tc.desc: Test ProxyRunningLock function, test Scene runninglock, HDI unlock() return RUNNINGLOCK_NOT_SUPPORT
688  * @tc.type: FUNC
689  * @tc.require: issueI6S0YY
690  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest011, TestSize.Level2)691 HWTEST_F (RunningLockMockTest, RunningLockMockTest011, TestSize.Level2)
692 {
693     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest011 start.");
694     ASSERT_NE(g_powerService, nullptr);
695     ASSERT_NE(g_lockAction, nullptr);
696 
697     RunningLockInfo runninglockNavi("RunningLockMockNavi11.1", RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION);
698     auto runningLockMgr = g_powerService->GetRunningLockMgr();
699     uint32_t lockActionCount = 0;
700     uint32_t unlockActionCount = 0;
701     int32_t timeoutMs = -1;
702     pid_t curUid = getuid();
703     pid_t curPid = getpid();
704 
705     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
706             EXPECT_EQ(param.name, runninglockNavi.name);
707             EXPECT_EQ(param.type, runninglockNavi.type);
708             EXPECT_EQ(param.timeoutMs, timeoutMs);
709             lockActionCount++;
710             return RUNNINGLOCK_SUCCESS;
711         });
712     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
713             EXPECT_EQ(param.name, runninglockNavi.name);
714             EXPECT_EQ(param.type, runninglockNavi.type);
715             unlockActionCount++;
716             return RUNNINGLOCK_NOT_SUPPORT;
717         });
718 
719     sptr<IRemoteObject> naviToken = new RunningLockTokenStub();
720     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(naviToken, runninglockNavi));
721     auto naviLock = runningLockMgr->GetRunningLockInner(naviToken);
722 
723     g_powerService->Lock(naviToken);
724     EXPECT_EQ(lockActionCount, 1);
725     EXPECT_TRUE(naviLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
726 
727     EXPECT_TRUE(g_powerService->ProxyRunningLock(true, curPid, curUid));
728 
729     EXPECT_EQ(unlockActionCount, 1);
730     EXPECT_TRUE(naviLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
731 
732     EXPECT_TRUE(g_powerService->ProxyRunningLock(false, curPid, curUid));
733 
734     EXPECT_EQ(lockActionCount, 1);
735     EXPECT_TRUE(naviLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
736 
737     g_powerService->UnLock(naviToken);
738     g_powerService->ReleaseRunningLock(naviToken);
739     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest011 end.");
740 }
741 
742 /**
743  * @tc.name: RunningLockMockTest012
744  * @tc.desc: Test ProxyRunningLock function, test Scene runninglock, HDI unlock() return RUNNINGLOCK_SUCCESS
745  * @tc.type: FUNC
746  * @tc.require: issueI6S0YY
747  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest012, TestSize.Level2)748 HWTEST_F (RunningLockMockTest, RunningLockMockTest012, TestSize.Level2)
749 {
750     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest012 start.");
751     ASSERT_NE(g_powerService, nullptr);
752     ASSERT_NE(g_lockAction, nullptr);
753 
754     RunningLockInfo runninglockTask("RunningLockMockTask12.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
755     auto runningLockMgr = g_powerService->GetRunningLockMgr();
756     uint32_t lockActionCount = 0;
757     uint32_t unlockActionCount = 0;
758     int32_t timeoutMs = -1;
759     pid_t curUid = getuid();
760     pid_t curPid = getpid();
761 
762     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
763             EXPECT_EQ(param.name, runninglockTask.name);
764             EXPECT_EQ(param.type, runninglockTask.type);
765             EXPECT_EQ(param.timeoutMs, timeoutMs);
766             lockActionCount++;
767             return RUNNINGLOCK_SUCCESS;
768         });
769     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
770             EXPECT_EQ(param.name, runninglockTask.name);
771             EXPECT_EQ(param.type, runninglockTask.type);
772             unlockActionCount++;
773             return RUNNINGLOCK_SUCCESS;
774         });
775 
776     sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
777     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
778     auto taskLock = runningLockMgr->GetRunningLockInner(taskToken);
779 
780     g_powerService->Lock(taskToken);
781     EXPECT_EQ(lockActionCount, 1);
782     EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
783 
784 
785     EXPECT_TRUE(g_powerService->ProxyRunningLocks(true, {std::make_pair(curPid, curUid)}));
786     EXPECT_EQ(unlockActionCount, 1);
787     EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
788 
789 
790     EXPECT_TRUE(g_powerService->ProxyRunningLocks(false, {std::make_pair(curPid, curUid)}));
791     EXPECT_EQ(lockActionCount, 2);
792     EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
793 
794     g_powerService->UnLock(taskToken);
795     g_powerService->ReleaseRunningLock(taskToken);
796     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest012 end.");
797 }
798 
799 /**
800  * @tc.name: RunningLockMockTest013
801  * @tc.desc: Test ProxyRunningLock function, runninglock release first, then cancel the proxy
802  * @tc.type: FUNC
803  * @tc.require: issueI6TW2R
804  */
HWTEST_F(RunningLockMockTest, RunningLockMockTest013, TestSize.Level2)805 HWTEST_F (RunningLockMockTest, RunningLockMockTest013, TestSize.Level2)
806 {
807     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest013 start.");
808     ASSERT_NE(g_powerService, nullptr);
809     ASSERT_NE(g_lockAction, nullptr);
810 
811     RunningLockInfo runninglockTask("RunningLockMockTask13.1", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
812     auto runningLockMgr = g_powerService->GetRunningLockMgr();
813     uint32_t lockActionCount = 0;
814     uint32_t unlockActionCount = 0;
815     int32_t timeoutMs = -1;
816     pid_t curUid = getuid();
817     pid_t curPid = getpid();
818 
819     EXPECT_CALL(*g_lockAction, Lock(_)).WillRepeatedly([&](const RunningLockParam& param) {
820             EXPECT_EQ(param.name, runninglockTask.name);
821             EXPECT_EQ(param.type, runninglockTask.type);
822             EXPECT_EQ(param.timeoutMs, timeoutMs);
823             lockActionCount++;
824             return RUNNINGLOCK_SUCCESS;
825         });
826     EXPECT_CALL(*g_lockAction, Unlock(_)).WillRepeatedly([&](const RunningLockParam& param) {
827             EXPECT_EQ(param.name, runninglockTask.name);
828             EXPECT_EQ(param.type, runninglockTask.type);
829             unlockActionCount++;
830             return RUNNINGLOCK_SUCCESS;
831         });
832 
833     sptr<IRemoteObject> taskToken = new RunningLockTokenStub();
834     EXPECT_EQ(PowerErrors::ERR_OK, g_powerService->CreateRunningLock(taskToken, runninglockTask));
835     auto taskLock = runningLockMgr->GetRunningLockInner(taskToken);
836 
837     g_powerService->Lock(taskToken);
838     EXPECT_EQ(lockActionCount, 1);
839     EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_ENABLE);
840 
841     EXPECT_TRUE(g_powerService->ProxyRunningLock(true, curPid, curUid));
842 
843     EXPECT_EQ(unlockActionCount, 1);
844     EXPECT_TRUE(taskLock->GetState() == RunningLockState::RUNNINGLOCK_STATE_PROXIED);
845 
846     g_powerService->UnLock(taskToken);
847     g_powerService->ReleaseRunningLock(taskToken);
848     EXPECT_EQ(runningLockMgr->GetRunningLockInner(taskToken), nullptr);
849 
850     EXPECT_TRUE(g_powerService->ProxyRunningLock(false, curPid, curUid));
851 
852     EXPECT_EQ(lockActionCount, 1);
853     POWER_HILOGD(LABEL_TEST, "RunningLockMockTest013 end.");
854 }
855 }
856