1 /*
2  * Copyright (c) 2021-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_native_test.h"
17 
18 #include <ipc_skeleton.h>
19 
20 #include "actions/irunning_lock_action.h"
21 
22 using namespace testing::ext;
23 using namespace OHOS::PowerMgr;
24 using namespace OHOS;
25 using namespace std;
26 
27 namespace {
28 constexpr int64_t CALLTIMEMS = 1;
29 constexpr pid_t PID = 1;
30 constexpr pid_t PID_A = 2;
31 constexpr pid_t UNPID = -1;
32 constexpr pid_t UID = 1;
33 constexpr pid_t UID_A = 2;
34 constexpr pid_t UNUID = -1;
35 constexpr uint32_t LOCKNUM_A = 0;
36 constexpr uint32_t LOCKNUM_B = 1;
37 constexpr int32_t TIMEOUTMS = 7;
38 constexpr uint32_t MAXTYPE = 77;
39 constexpr int32_t UNTYPE = -1;
40 } //namespace
41 
HandleRunningLockMessage(std::string message)42 void PowerRunningLockTestCallback::HandleRunningLockMessage(std::string message)
43 {
44     POWER_HILOGI(LABEL_TEST,
45         "PowerRunningLockTestCallback::HandleRunningLockMessage, %{public}s", message.c_str());
46 }
47 namespace {
48 /**
49  * @tc.name: RunningLockNative001
50  * @tc.desc: test init in runningLockMgr
51  * @tc.type: FUNC
52  */
53 HWTEST_F (RunningLockNativeTest, RunningLockNative001, TestSize.Level0)
54 {
55     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
56     pmsTest->OnStart();
57     auto stateMachine = pmsTest->GetPowerStateMachine();
58     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
59     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
60 
61     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
62     EXPECT_TRUE(runningLockMgr->Init());
63     sptr<IRemoteObject> remoteObject = new RunningLockTokenStub();
64     EXPECT_TRUE(runningLockMgr->GetRunningLockInner(remoteObject) == nullptr);
65     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
66     int32_t pid = IPCSkeleton::GetCallingPid();
67     int32_t uid = IPCSkeleton::GetCallingUid();
68     RunningLockParam runningLockParam {0,
69         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, pid, uid};
70     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
71     EXPECT_FALSE(runningLockMgr->IsUsed(remoteObj));
72     runningLockMgr->Lock(remoteObj);
73     EXPECT_TRUE(runningLockMgr->GetRunningLockNum(RunningLockType::RUNNINGLOCK_SCREEN) == LOCKNUM_B);
74     EXPECT_TRUE(runningLockMgr->GetRunningLockNum(RunningLockType::RUNNINGLOCK_BUTT) == LOCKNUM_B);
75     EXPECT_TRUE(runningLockMgr->GetValidRunningLockNum(RunningLockType::RUNNINGLOCK_SCREEN) == LOCKNUM_B);
76     EXPECT_TRUE(runningLockMgr->GetValidRunningLockNum(static_cast<RunningLockType>(MAXTYPE)) == LOCKNUM_A);
77     EXPECT_TRUE(runningLockMgr->IsUsed(remoteObj));
78     sptr<IRemoteObject> token = new RunningLockTokenStub();
79     EXPECT_FALSE(runningLockMgr->IsUsed(token));
80     runningLockMgr->Lock(token);
81     runningLockMgr->UnLock(remoteObj);
82     runningLockMgr->UnLock(token);
83 
84     EXPECT_FALSE(runningLockMgr->ReleaseLock(remoteObj));
85     EXPECT_FALSE(runningLockMgr->ReleaseLock(token));
86 
87     POWER_HILOGI(LABEL_TEST, "RunningLockNative001 end");
88 }
89 
90 /**
91  * @tc.name: RunningLockNative002
92  * @tc.desc: test proxyRunningLock in runningLockMgr
93  * @tc.type: FUNC
94  */
95 HWTEST_F (RunningLockNativeTest, RunningLockNative002, TestSize.Level0)
96 {
97     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
98     pmsTest->OnStart();
99     auto stateMachine = pmsTest->GetPowerStateMachine();
100     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
101     stateMachine->RefreshActivityInner(UID, PID, userActivityType, true);
102 
103     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
104     EXPECT_TRUE(runningLockMgr->Init());
105     EXPECT_FALSE(runningLockMgr->ExistValidRunningLock());
106     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
107     int32_t pid = IPCSkeleton::GetCallingPid();
108     int32_t uid = IPCSkeleton::GetCallingUid();
109     RunningLockParam runningLockParam {0,
110         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, pid, uid};
111     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
112     EXPECT_FALSE(runningLockMgr->ExistValidRunningLock());
113     runningLockMgr->Lock(remoteObj);
114     EXPECT_TRUE(runningLockMgr->ExistValidRunningLock() == true);
115 
116     runningLockMgr->ProxyRunningLock(false, pid, uid);
117     runningLockMgr->ProxyRunningLock(true, pid, uid);
118     runningLockMgr->ProxyRunningLock(true, pid, uid);
119     runningLockMgr->ProxyRunningLock(true, UNPID, UID);
120     runningLockMgr->ProxyRunningLock(true, UNPID, UID);
121     runningLockMgr->ProxyRunningLock(false, pid, uid);
122     runningLockMgr->ProxyRunningLock(false, UNPID, UID);
123 
124     runningLockMgr->UnLock(remoteObj);
125     EXPECT_FALSE(runningLockMgr->ReleaseLock(remoteObj));
126     POWER_HILOGI(LABEL_TEST, "RunningLockNative002 end");
127 }
128 
129 /**
130  * @tc.name: RunningLockNative003
131  * @tc.desc: test enableMock and dumpInfo in runningLockMgr
132  * @tc.type: FUNC
133  */
134 HWTEST_F (RunningLockNativeTest, RunningLockNative003, TestSize.Level0)
135 {
136     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
137     pmsTest->OnStart();
138     auto stateMachine = pmsTest->GetPowerStateMachine();
139     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
140     stateMachine->RefreshActivityInner(UID, PID, userActivityType, true);
141 
142     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
143     EXPECT_TRUE(runningLockMgr->Init());
144     IRunningLockAction *runLockAction = new RunningLockAction();
145     runningLockMgr->EnableMock(runLockAction);
146     std::string result;
147     runningLockMgr->DumpInfo(result);
148 
149     RunningLockParam runningLockParam {0,
150         "runninglockNativeTest2", "", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, TIMEOUTMS, PID, UID};
151     sptr<IRemoteObject> token = new RunningLockTokenStub();
152     EXPECT_TRUE(runningLockMgr->CreateRunningLock(token, runningLockParam) != nullptr);
153     runningLockMgr->DumpInfo(result);
154     runningLockMgr->Lock(token);
155     runningLockMgr->UnLock(token);
156 
157     EXPECT_FALSE(runningLockMgr->ReleaseLock(token));
158     POWER_HILOGI(LABEL_TEST, "RunningLockNative003 end");
159 }
160 
161 /**
162  * @tc.name: RunningLockNative004
163  * @tc.desc: test setProximity in runningLockMgr
164  * @tc.type: FUNC
165  */
166 HWTEST_F (RunningLockNativeTest, RunningLockNative004, TestSize.Level0)
167 {
168     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
169     pmsTest->OnStart();
170     auto stateMachine = pmsTest->GetPowerStateMachine();
171     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
172     stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
173 
174     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
175     EXPECT_TRUE(runningLockMgr->Init());
176     runningLockMgr->SetProximity(RunningLockMgr::PROXIMITY_AWAY);
177     runningLockMgr->SetProximity(RunningLockMgr::PROXIMITY_CLOSE);
178     runningLockMgr->SetProximity(MAXTYPE);
179 
180     RunningLockParam runningLockParam {0,
181         "runninglockNativeTest", "", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, TIMEOUTMS, PID, UID};
182     sptr<IRemoteObject> token = new RunningLockTokenStub();
183     EXPECT_TRUE(runningLockMgr->CreateRunningLock(token, runningLockParam) != nullptr);
184     runningLockMgr->Lock(token);
185     runningLockMgr->SetProximity(RunningLockMgr::PROXIMITY_AWAY);
186     runningLockMgr->SetProximity(RunningLockMgr::PROXIMITY_CLOSE);
187     runningLockMgr->SetProximity(RunningLockMgr::PROXIMITY_CLOSE);
188     runningLockMgr->SetProximity(RunningLockMgr::PROXIMITY_AWAY);
189     runningLockMgr->UnLock(token);
190 
191     RunningLockParam runningLockParam2 {0,
192         "runninglockNativeTest2", "", static_cast<RunningLockType>(7U), TIMEOUTMS, PID_A, UID_A};
193     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
194     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam2) != nullptr);
195     runningLockMgr->Lock(remoteObj);
196     runningLockMgr->UnLock(remoteObj);
197     POWER_HILOGI(LABEL_TEST, "RunningLockNative004 end");
198 }
199 
200 /**
201  * @tc.name: RunningLockNative005
202  * @tc.desc: test lock and unlock in runningLockMgr
203  * @tc.type: FUNC
204  */
205 HWTEST_F (RunningLockNativeTest, RunningLockNative005, TestSize.Level0)
206 {
207     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
208     pmsTest->OnStart();
209     auto stateMachine = pmsTest->GetPowerStateMachine();
210     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
211     stateMachine->RefreshActivityInner(UID, PID, userActivityType, true);
212 
213     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
214     EXPECT_TRUE(runningLockMgr->Init());
215     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
216     RunningLockParam runningLockParam {0,
217         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, UNPID, UNUID};
218     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
219     runningLockMgr->Lock(remoteObj);
220     runningLockMgr->Lock(remoteObj);
221     RunningLockParam runningLockParam1 {0,
222         "runninglockNativeTest2", "", static_cast<RunningLockType>(MAXTYPE), TIMEOUTMS, UNPID, UNUID};
223     sptr<IRemoteObject> token = new RunningLockTokenStub();
224     EXPECT_TRUE(runningLockMgr->CreateRunningLock(token, runningLockParam1) != nullptr);
225     runningLockMgr->Lock(token);
226     runningLockMgr->UnLock(token);
227 
228     EXPECT_FALSE(runningLockMgr->ReleaseLock(remoteObj));
229     EXPECT_FALSE(runningLockMgr->ReleaseLock(token));
230     POWER_HILOGI(LABEL_TEST, "RunningLockNative005 end");
231 }
232 
233 /**
234  * @tc.name: RunningLockNative006
235  * @tc.desc: test callback in runningLockMgr
236  * @tc.type: FUNC
237  */
238 HWTEST_F (RunningLockNativeTest, RunningLockNative006, TestSize.Level0)
239 {
240     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
241     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
242     EXPECT_TRUE(runningLockMgr->Init());
243     RunningLockParam runningLockParam {0,
244         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, UNPID, UNUID};
245     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
246     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
247     runningLockMgr->Lock(remoteObj);
248 
249     runningLockMgr->NotifyRunningLockChanged(runningLockParam, "DUBAI_TAG_RUNNINGLOCK_REMOVE");
250     runningLockMgr->NotifyRunningLockChanged(runningLockParam, "DUBAI_TAG_RUNNINGLOCK_ADD");
251     runningLockMgr->NotifyRunningLockChanged(runningLockParam, "DUBAI_TAG_RUNNINGLOCK_REMOVE");
252 
253     auto runningLockMgrController = std::make_shared<RunningLockMgr::ProximityController>();
254     SensorEvent sensorEvent;
255     ProximityData data;
256     data.distance = RunningLockMgr::ProximityController::PROXIMITY_CLOSE_SCALAR;
257     sensorEvent.sensorTypeId = SENSOR_TYPE_ID_PROXIMITY;
258     sensorEvent.data = reinterpret_cast<uint8_t*>(&data);
259     runningLockMgrController->RecordSensorCallback(&sensorEvent);
260     data.distance = RunningLockMgr::ProximityController::PROXIMITY_AWAY_SCALAR;
261     runningLockMgrController->RecordSensorCallback(&sensorEvent);
262     data.distance = RunningLockMgr::ProximityController::SAMPLING_RATE;
263     runningLockMgrController->RecordSensorCallback(&sensorEvent);
264     sensorEvent.sensorTypeId = TIMEOUTMS;
265     runningLockMgrController->RecordSensorCallback(&sensorEvent);
266     runningLockMgrController->RecordSensorCallback(nullptr);
267     runningLockMgrController->support_ = true;
268     runningLockMgrController->Enable();
269     runningLockMgrController->Disable();
270 
271     EXPECT_FALSE(runningLockMgr->ReleaseLock(remoteObj));
272     POWER_HILOGI(LABEL_TEST, "RunningLockNative006 end");
273 }
274 
275 /**
276  * @tc.name: RunningLockNative007
277  * @tc.desc: test activate in lockCounters
278  * @tc.type: FUNC
279  * @tc.require: issueI7MNRN
280  */
281 HWTEST_F(RunningLockNativeTest, RunningLockNative007, TestSize.Level0)
282 {
283     auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
284     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest_);
285     EXPECT_TRUE(runningLockMgr->Init());
286     std::shared_ptr<RunningLockMgr::LockCounter> ptr1 =
287         runningLockMgr->lockCounters_[RunningLockType::RUNNINGLOCK_SCREEN];
288     RunningLockParam runningLockParam1;
289     ptr1->activate_(true, runningLockParam1);
290     ptr1->activate_(false, runningLockParam1);
291     EXPECT_TRUE(runningLockMgr->lockCounters_.size() != 0);
292 
293     pmsTest_->powerStateMachine_->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
294     std::shared_ptr<RunningLockMgr::LockCounter> ptr2 =
295         runningLockMgr->lockCounters_[RunningLockType::RUNNINGLOCK_BACKGROUND_TASK];
296     RunningLockParam runningLockParam2 {0,
297         "RunningLockNative007", "", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK, -1, 0, 0};
298     ptr2->activate_(true, runningLockParam2);
299     ptr2->activate_(false, runningLockParam2);
300     EXPECT_TRUE(runningLockMgr->lockCounters_.size() != 0);
301 
302     pmsTest_->powerStateMachine_->SetState(PowerState::FREEZE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
303     RunningLockParam runningLockParam3;
304     ptr2->activate_(true, runningLockParam3);
305     ptr2->activate_(false, runningLockParam3);
306     EXPECT_TRUE(runningLockMgr->lockCounters_.size() != 0);
307 
308     std::shared_ptr<RunningLockMgr::LockCounter> ptr3 =
309         runningLockMgr->lockCounters_[RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL];
310     RunningLockParam runningLockParam4;
311     ptr3->activate_(true, runningLockParam4);
312     ptr3->activate_(false, runningLockParam4);
313     EXPECT_TRUE(runningLockMgr->lockCounters_.size() != 0);
314 
315     auto stateMachine = pmsTest_->GetPowerStateMachine();
316     pmsTest_->powerStateMachine_ = nullptr;
317     RunningLockParam runningLockParam5;
318     ptr3->activate_(true, runningLockParam5);
319     pmsTest_->powerStateMachine_ = stateMachine;
320     EXPECT_TRUE(pmsTest_->powerStateMachine_ != nullptr);
321 
322     POWER_HILOGI(LABEL_TEST, "RunningLockNative007 end");
323 }
324 
325 /**
326  * @tc.name: RunningLockNative009
327  * @tc.desc: test Lock
328  * @tc.type: FUNC
329  * @tc.require: issueI7MNRN
330  */
331 HWTEST_F(RunningLockNativeTest, RunningLockNative009, TestSize.Level0)
332 {
333     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
334     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
335     EXPECT_TRUE(runningLockMgr->Init());
336     sptr<IRemoteObject> remoteObject = new RunningLockTokenStub();
337     runningLockMgr->Lock(remoteObject);
338     runningLockMgr->UnLock(remoteObject);
339     EXPECT_TRUE(runningLockMgr != nullptr);
340     POWER_HILOGI(LABEL_TEST, "RunningLockNative009 end");
341 }
342 
343 /**
344  * @tc.name: RunningLockNative010
345  * @tc.desc: test Lock
346  * @tc.type: FUNC
347  * @tc.require: issueI7MNRN
348  */
349 HWTEST_F(RunningLockNativeTest, RunningLockNative010, TestSize.Level0)
350 {
351     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
352     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
353     EXPECT_TRUE(runningLockMgr->Init());
354     sptr<IRemoteObject> remoteObject = new RunningLockTokenStub();
355     runningLockMgr->UnLock(remoteObject);
356     EXPECT_TRUE(runningLockMgr != nullptr);
357     runningLockMgr->lockCounters_.clear();
358     runningLockMgr->UnLock(remoteObject);
359     EXPECT_TRUE(runningLockMgr != nullptr);
360     POWER_HILOGI(LABEL_TEST, "RunningLockNative010 end");
361 }
362 
363 /**
364  * @tc.name: RunningLockNative011
365  * @tc.desc: test IsUsed
366  * @tc.type: FUNC
367  * @tc.require: issueI7MNRN
368  */
369 HWTEST_F(RunningLockNativeTest, RunningLockNative011, TestSize.Level0)
370 {
371     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
372     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
373     EXPECT_TRUE(runningLockMgr->Init());
374     sptr<IRemoteObject> remoteObject = new RunningLockTokenStub();
375     runningLockMgr->IsUsed(remoteObject);
376     EXPECT_TRUE(runningLockMgr != nullptr);
377     POWER_HILOGI(LABEL_TEST, "RunningLockNative011 end");
378 }
379 
380 /**
381  * @tc.name: RunningLockNative012
382  * @tc.desc: test GetRunningLockNum
383  * @tc.type: FUNC
384  * @tc.require: issueI7MNRN
385  */
386 HWTEST_F(RunningLockNativeTest, RunningLockNative012, TestSize.Level0)
387 {
388     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
389     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
390     EXPECT_TRUE(runningLockMgr->Init());
391     runningLockMgr->GetRunningLockNum(RunningLockType::RUNNINGLOCK_BUTT);
392     EXPECT_TRUE(runningLockMgr != nullptr);
393     POWER_HILOGI(LABEL_TEST, "RunningLockNative012 end");
394 }
395 
396 /**
397  * @tc.name: RunningLockNative013
398  * @tc.desc: test GetValidRunningLockNum
399  * @tc.type: FUNC
400  * @tc.require: issueI7MNRN
401  */
402 HWTEST_F(RunningLockNativeTest, RunningLockNative013, TestSize.Level0)
403 {
404     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
405     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
406     EXPECT_TRUE(runningLockMgr->Init());
407     runningLockMgr->GetValidRunningLockNum(static_cast<RunningLockType>(-1));
408     EXPECT_TRUE(runningLockMgr != nullptr);
409     POWER_HILOGI(LABEL_TEST, "RunningLockNative013 end");
410 }
411 
412 /**
413  * @tc.name: RunningLockNative014
414  * @tc.desc: test NotifyRunningLockChanged
415  * @tc.type: FUNC
416  * @tc.require: issueI7MNRN
417  */
418 HWTEST_F(RunningLockNativeTest, RunningLockNative014, TestSize.Level0)
419 {
420     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
421     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
422     EXPECT_TRUE(runningLockMgr->Init());
423     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
424     RunningLockParam runningLockParam {0,
425         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, UNPID, UNUID};
426     runningLockMgr->NotifyRunningLockChanged(runningLockParam, "DUBAI_TAG_RUNNINGLOCK_ADD");
427     runningLockMgr->NotifyRunningLockChanged(runningLockParam, "DUBAI_TAG_RUNNINGLOCK_REMOVE");
428     EXPECT_TRUE(runningLockMgr != nullptr);
429     POWER_HILOGI(LABEL_TEST, "RunningLockNative014 end");
430 }
431 
432 /**
433  * @tc.name: RunningLockNative015
434  * @tc.desc: test ProxyRunningLock
435  * @tc.type: FUNC
436  * @tc.require: issueI7MNRN
437  */
438 HWTEST_F(RunningLockNativeTest, RunningLockNative015, TestSize.Level0)
439 {
440     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
441     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
442     EXPECT_TRUE(runningLockMgr->Init());
443 
444     pid_t pid = 1;
445     pid_t uid = 0;
446     EXPECT_TRUE(runningLockMgr->ProxyRunningLock(true, pid, uid) == true);
447     EXPECT_TRUE(runningLockMgr->ProxyRunningLock(false, pid, uid) == true);
448     EXPECT_TRUE(runningLockMgr->ProxyRunningLock(true, 0, uid) == false);
449     POWER_HILOGI(LABEL_TEST, "RunningLockNative015 end");
450 }
451 
452 /**
453  * @tc.name: RunningLockNative016
454  * @tc.desc: test ProxyRunningLockInner
455  * @tc.type: FUNC
456  * @tc.require: issueI7MNRN
457  */
458 HWTEST_F(RunningLockNativeTest, RunningLockNative016, TestSize.Level0)
459 {
460     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
461     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
462     EXPECT_TRUE(runningLockMgr->Init());
463 
464     pid_t pid = 0;
465     pid_t uid = 0;
466     EXPECT_TRUE(runningLockMgr != nullptr);
467 
468     RunningLockParam runningLockParam {0,
469         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, UNPID, UNUID};
470     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
471     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
472     EXPECT_TRUE(runningLockMgr != nullptr);
473     EXPECT_TRUE(runningLockMgr != nullptr);
474     runningLockMgr->runninglockProxy_->AddRunningLock(pid, uid, nullptr);
475     EXPECT_TRUE(runningLockMgr != nullptr);
476     POWER_HILOGI(LABEL_TEST, "RunningLockNative016 end");
477 }
478 
479 /**
480  * @tc.name: RunningLockNative017
481  * @tc.desc: test DumpInfo
482  * @tc.type: FUNC
483  * @tc.require: issueI7MNRN
484  */
485 HWTEST_F(RunningLockNativeTest, RunningLockNative017, TestSize.Level0)
486 {
487     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
488     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
489     EXPECT_TRUE(runningLockMgr->Init());
490     std::string result;
491     RunningLockParam runningLockParam {0,
492         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, UNPID, UNUID};
493     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
494     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
495     runningLockMgr->DumpInfo(result);
496     EXPECT_TRUE(runningLockMgr != nullptr);
497     runningLockMgr->runningLocks_.clear();
498     runningLockMgr->DumpInfo(result);
499     EXPECT_TRUE(runningLockMgr != nullptr);
500 
501     POWER_HILOGI(LABEL_TEST, "RunningLockNative017 end");
502 }
503 
504 /**
505  * @tc.name: RunningLockNative018
506  * @tc.desc: test Lock
507  * @tc.type: FUNC
508  * @tc.require: issueI7MNRN
509  */
510 HWTEST_F(RunningLockNativeTest, RunningLockNative018, TestSize.Level0)
511 {
512     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
513     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
514     EXPECT_TRUE(runningLockMgr->Init());
515     EXPECT_TRUE(runningLockMgr != nullptr);
516     POWER_HILOGI(LABEL_TEST, "RunningLockNative018 end");
517 }
518 
519 /**
520  * @tc.name: RunningLockNative019
521  * @tc.desc: test Unlock
522  * @tc.type: FUNC
523  * @tc.require: issueI7MNRN
524  */
525 HWTEST_F(RunningLockNativeTest, RunningLockNative019, TestSize.Level0)
526 {
527     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
528     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
529     EXPECT_TRUE(runningLockMgr->Init());
530     EXPECT_TRUE(runningLockMgr != nullptr);
531     POWER_HILOGI(LABEL_TEST, "RunningLockNative019 end");
532 }
533 
534 /**
535  * @tc.name: RunningLockNative020
536  * @tc.desc: test activate in lockCounters
537  * @tc.type: FUNC
538  * @tc.require: issueI7MNRN
539  */
540 HWTEST_F(RunningLockNativeTest, RunningLockNative020, TestSize.Level0)
541 {
542     auto pmsTest_ = DelayedSpSingleton<PowerMgrService>::GetInstance();
543     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest_);
544     EXPECT_TRUE(runningLockMgr->Init());
545     RunningLockParam runningLockParam {0,
546         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, UNPID, UNUID};
547     runningLockMgr->lockCounters_[RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL]->Increase(
548         runningLockParam);
549     EXPECT_TRUE(runningLockMgr != nullptr);
550     runningLockMgr->lockCounters_[RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL]->Decrease(
551         runningLockParam);
552     EXPECT_TRUE(runningLockMgr != nullptr);
553     POWER_HILOGI(LABEL_TEST, "RunningLockNative020 end");
554 }
555 
556 /**
557  * @tc.name: RunningLockNative021
558  * @tc.desc: test callback in NotifyRunningLockChanged
559  * @tc.type: FUNC
560  * @tc.require: issueI9C4GG
561  */
562 HWTEST_F(RunningLockNativeTest, RunningLockNative021, TestSize.Level0)
563 {
564     POWER_HILOGI(LABEL_TEST, "RunningLockNative021::fun is start!");
565     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
566     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
567     EXPECT_TRUE(runningLockMgr->Init());
568     sptr<IPowerRunninglockCallback> callback1 = new PowerRunningLockTestCallback();
569     runningLockMgr->RegisterRunningLockCallback(callback1);
570     RunningLockParam runningLockParam1 {0,
571         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, UNPID, UNUID};
572     runningLockMgr->NotifyRunningLockChanged(runningLockParam1, "DUBAI_TAG_RUNNINGLOCK_ADD");
573     runningLockMgr->NotifyRunningLockChanged(runningLockParam1, "DUBAI_TAG_RUNNINGLOCK_REMOVE");
574 
575     sptr<IPowerRunninglockCallback> callback2 =new PowerRunningLockTestCallback();
576     runningLockMgr->RegisterRunningLockCallback(callback2);
577     RunningLockParam runningLockParam2 {0, "runninglockNativeTest2", "",
578         RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, TIMEOUTMS, UNPID, UNUID};
579     runningLockMgr->NotifyRunningLockChanged(runningLockParam2, "DUBAI_TAG_RUNNINGLOCK_ADD");
580     runningLockMgr->NotifyRunningLockChanged(runningLockParam2, "DUBAI_TAG_RUNNINGLOCK_REMOVE");
581 
582     runningLockMgr->UnRegisterRunningLockCallback(callback2);
583     RunningLockParam runningLockParam3 {0, "runninglockNativeTest3", "",
584         RunningLockType::RUNNINGLOCK_BACKGROUND_TASK, TIMEOUTMS, UNPID, UNUID};
585     runningLockMgr->NotifyRunningLockChanged(runningLockParam3, "DUBAI_TAG_RUNNINGLOCK_ADD");
586     runningLockMgr->NotifyRunningLockChanged(runningLockParam3, "DUBAI_TAG_RUNNINGLOCK_REMOVE");
587     EXPECT_TRUE(runningLockMgr != nullptr);
588     POWER_HILOGI(LABEL_TEST, "RunningLockNative021::fun is end!");
589 }
590 
591 /**
592  * @tc.name: RunningLockNative022
593  * @tc.desc: test the activation of screen-on-lock
594  * @tc.type: FUNC
595  */
596 HWTEST_F(RunningLockNativeTest, RunningLockNative022, TestSize.Level0)
597 {
598     POWER_HILOGI(LABEL_TEST, "RunningLockNative022 function started!");
599     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
600     pmsTest->OnStart();
601     auto runningLockMgr = pmsTest->GetRunningLockMgr();
602 
603     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
604     int32_t pid = IPCSkeleton::GetCallingPid();
605     int32_t uid = IPCSkeleton::GetCallingUid();
606     RunningLockParam runningLockParam {0,
607         "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, -1, pid, uid};
608     EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
609     EXPECT_FALSE(runningLockMgr->IsUsed(remoteObj));
610 
611     pmsTest->OverrideScreenOffTime(5000);
612     auto stateMachine = pmsTest->GetPowerStateMachine();
613 
614     stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
615     EXPECT_EQ(stateMachine->GetState(), PowerState::INACTIVE);
616     runningLockMgr->Lock(remoteObj);
617     // screen on lock should not turn screen on if it is already off
618     EXPECT_EQ(stateMachine->GetState(), PowerState::INACTIVE);
619     runningLockMgr->UnLock(remoteObj);
620 
621     // the minimum interval between RefreshActivity is 100 ms
622     usleep(100000);
623     stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
624     EXPECT_EQ(stateMachine->GetState(), PowerState::AWAKE);
625     stateMachine->SetState(PowerState::DIM, StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
626     EXPECT_EQ(stateMachine->GetState(), PowerState::DIM);
627     runningLockMgr->Lock(remoteObj);
628     // after the activation of screen-on lock the screen should no longer be in DIM state
629     EXPECT_EQ(stateMachine->GetState(), PowerState::AWAKE);
630     runningLockMgr->UnLock(remoteObj);
631 
632     pmsTest->RestoreScreenOffTime();
633 }
634 
635 /**
636  * @tc.name: RunningLockNative023
637  * @tc.desc: test enableMock and dumpInfo in runningLockMgr
638  * @tc.type: FUNC
639  */
640 HWTEST_F (RunningLockNativeTest, RunningLockNative023, TestSize.Level0)
641 {
642     auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
643     pmsTest->OnStart();
644     auto stateMachine = pmsTest->GetPowerStateMachine();
645     UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
646     stateMachine->RefreshActivityInner(UID, PID, userActivityType, true);
647 
648     auto runningLockMgr = std::make_shared<RunningLockMgr>(pmsTest);
649     EXPECT_TRUE(runningLockMgr->Init());
650     IRunningLockAction *runLockAction = new RunningLockAction();
651     runningLockMgr->EnableMock(runLockAction);
652     std::string result;
653     runningLockMgr->DumpInfo(result);
654 
655     RunningLockParam runningLockParam {0,
656         "runninglockNativeTest023", "", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO, TIMEOUTMS, PID, UID};
657     sptr<IRemoteObject> token = new RunningLockTokenStub();
658     EXPECT_TRUE(runningLockMgr->CreateRunningLock(token, runningLockParam) != nullptr);
659     runningLockMgr->Lock(token);
660     runningLockMgr->UpdateWorkSource(token, {{0, ""}});
661     runningLockMgr->DumpInfo(result);
662     runningLockMgr->UnLock(token);
663 
664     EXPECT_FALSE(runningLockMgr->ReleaseLock(token));
665     POWER_HILOGI(LABEL_TEST, "RunningLockNative023 end");
666 }
667 } // namespace
668