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