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