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_test.h"
17 
18 #include <ipc_skeleton.h>
19 
20 #include "actions/irunning_lock_action.h"
21 #include "power_mgr_service.h"
22 #include "running_lock_mgr.h"
23 #include "power_log.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS::PowerMgr;
27 using namespace OHOS;
28 using namespace std;
29 
30 namespace {
31 constexpr int32_t US_PER_MS = 1000;
32 constexpr int32_t app0Uid = 8;
33 constexpr int32_t app1Uid = 9;
34 }
35 
36 namespace {
37 /**
38  * @tc.name: RunningLockTest001
39  * @tc.desc: Test RunningLockInnerKit function, connect PowerMgrService and call member function.
40  * @tc.type: FUNC
41  */
HWTEST_F(RunningLockTest, RunningLockTest001, TestSize.Level0)42 HWTEST_F (RunningLockTest, RunningLockTest001, TestSize.Level0)
43 {
44     POWER_HILOGD(LABEL_TEST, "RunningLockTest001 start");
45     auto& powerMgrClient = PowerMgrClient::GetInstance();
46     auto runningLock1 = powerMgrClient.CreateRunningLock("runninglock1", RunningLockType::RUNNINGLOCK_SCREEN);
47     ASSERT_TRUE(runningLock1 != nullptr);
48 
49     ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
50     runningLock1->Lock();
51     ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
52 
53     runningLock1->UnLock();
54     ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
55     POWER_HILOGD(LABEL_TEST, "RunningLockTest001 end");
56 }
57 
58 /**
59  * @tc.name: RunningLockTest002
60  * @tc.desc: Test RunningLockInnerKit function, timeout lock.
61  * @tc.type: FUNC
62  */
HWTEST_F(RunningLockTest, RunningLockTest002, TestSize.Level1)63 HWTEST_F (RunningLockTest, RunningLockTest002, TestSize.Level1)
64 {
65     POWER_HILOGD(LABEL_TEST, "RunningLockTest002 start");
66     auto& powerMgrClient = PowerMgrClient::GetInstance();
67     auto runningLock1 = powerMgrClient.CreateRunningLock("runninglock1", RunningLockType::RUNNINGLOCK_SCREEN);
68     ASSERT_TRUE(runningLock1 != nullptr);
69     ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
70     runningLock1->Lock();
71     ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
72     runningLock1->UnLock();
73     ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
74     POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit003 1");
75     // lock 50ms
76     runningLock1->Lock(50);
77     usleep(4000);
78     POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit003 2");
79     ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
80     usleep(1000);
81     POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit003 3");
82     ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
83     // wait 100ms
84     usleep(100000);
85     POWER_HILOGD(LABEL_TEST, "RunningLockTest002 start");
86 }
87 
88 /**
89  * @tc.name: RunningLockTest003
90  * @tc.desc: Test RunningLockInnerKit function, timeout lock.
91  * @tc.type: FUNC
92  */
HWTEST_F(RunningLockTest, RunningLockTest003, TestSize.Level1)93 HWTEST_F (RunningLockTest, RunningLockTest003, TestSize.Level1)
94 {
95     POWER_HILOGD(LABEL_TEST, "RunningLockTest003 start");
96     if (false) {
97         auto& powerMgrClient = PowerMgrClient::GetInstance();
98         auto runningLock1 = powerMgrClient.CreateRunningLock("runninglock005",
99             RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
100         ASSERT_TRUE(runningLock1 != nullptr);
101         ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
102         // after 8ms unlock
103         runningLock1->Lock(30);
104         runningLock1->Lock(80);
105         POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit005 1");
106         usleep(50000);
107         ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
108         usleep(50000);
109         ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
110         // no unlock
111         POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit005 2");
112         runningLock1->Lock(2);
113         runningLock1->Lock(3);
114         runningLock1->Lock();
115         POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit005 3");
116         usleep(8000);
117         ASSERT_TRUE(runningLock1->IsUsed()) << "runningLock1->IsUsed() != true";
118         // after 3ms unlock
119         runningLock1->Lock(30);
120         POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit005 4");
121         usleep(50000);
122         ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
123         runningLock1->Lock(5);
124         runningLock1->UnLock();
125         ASSERT_TRUE(!runningLock1->IsUsed()) << "runningLock1->IsUsed() != false";
126         POWER_HILOGD(LABEL_TEST, "PowerMgrUnitTest::RunningLockInnerKit005 5");
127     }
128     POWER_HILOGD(LABEL_TEST, "RunningLockTest003 end");
129 }
130 
131 /**
132  * @tc.name: RunningLockTest004
133  * @tc.desc: Test CreateRunningLock function.
134  * @tc.type: FUNC
135  * @tc.require: issueI6NWQD
136  */
HWTEST_F(RunningLockTest, RunningLockTest004, TestSize.Level1)137 HWTEST_F (RunningLockTest, RunningLockTest004, TestSize.Level1)
138 {
139     POWER_HILOGD(LABEL_TEST, "RunningLockTest004 start");
140     auto& powerMgrClient = PowerMgrClient::GetInstance();
141     std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
142         "background", RunningLockType::RUNNINGLOCK_BACKGROUND);
143     EXPECT_NE(runningLock, nullptr);
144 
145     runningLock = powerMgrClient.CreateRunningLock("backgroudPhone", RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
146     EXPECT_NE(runningLock, nullptr);
147 
148     runningLock = powerMgrClient.CreateRunningLock(
149         "backgroudNatification", RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION);
150     EXPECT_NE(runningLock, nullptr);
151 
152     runningLock = powerMgrClient.CreateRunningLock("backgroudAudio", RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
153     EXPECT_NE(runningLock, nullptr);
154 
155     runningLock = powerMgrClient.CreateRunningLock("backgroudSport", RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT);
156     EXPECT_NE(runningLock, nullptr);
157 
158     runningLock = powerMgrClient.CreateRunningLock(
159         "backgroudNavigation", RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION);
160     EXPECT_NE(runningLock, nullptr);
161 
162     runningLock = powerMgrClient.CreateRunningLock("backgroudTask", RunningLockType::RUNNINGLOCK_BACKGROUND_TASK);
163     EXPECT_NE(runningLock, nullptr);
164 
165     runningLock = powerMgrClient.CreateRunningLock("butt", RunningLockType::RUNNINGLOCK_BUTT);
166     EXPECT_EQ(runningLock, nullptr);
167     POWER_HILOGD(LABEL_TEST, "RunningLockTest004 end");
168 }
169 
170 /**
171  * @tc.name: RunningLockTest005
172  * @tc.desc: Test ProxyRunningLock function.
173  * @tc.type: FUNC
174  * @tc.require: issueI6S0YY
175  */
HWTEST_F(RunningLockTest, RunningLockTest005, TestSize.Level1)176 HWTEST_F (RunningLockTest, RunningLockTest005, TestSize.Level1)
177 {
178     POWER_HILOGD(LABEL_TEST, "RunningLockTest005 start");
179     auto& powerMgrClient = PowerMgrClient::GetInstance();
180     std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
181         "background.test005", RunningLockType::RUNNINGLOCK_BACKGROUND);
182     ASSERT_NE(runningLock, nullptr);
183 
184     pid_t curUid = getuid();
185     pid_t curPid = getpid();
186     runningLock->Lock();
187     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, curUid));
188     EXPECT_FALSE(runningLock->IsUsed());
189     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, curUid));
190     runningLock->UnLock();
191     POWER_HILOGD(LABEL_TEST, "RunningLockTest005 end");
192 }
193 
194 /**
195  * @tc.name: RunningLockTest006
196  * @tc.desc: Test ProxyRunningLock function.
197  * @tc.type: FUNC
198  * @tc.require: issueI6S0YY
199  */
HWTEST_F(RunningLockTest, RunningLockTest006, TestSize.Level1)200 HWTEST_F (RunningLockTest, RunningLockTest006, TestSize.Level1)
201 {
202     POWER_HILOGD(LABEL_TEST, "RunningLockTest006 start");
203     auto& powerMgrClient = PowerMgrClient::GetInstance();
204     std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
205         "background.test006", RunningLockType::RUNNINGLOCK_SCREEN);
206     ASSERT_NE(runningLock, nullptr);
207 
208     pid_t curUid = getuid();
209     pid_t curPid = getpid();
210 
211     runningLock->Lock(-1);
212     EXPECT_TRUE(runningLock->IsUsed());
213 
214     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, curUid));
215     EXPECT_FALSE(runningLock->IsUsed());
216 
217     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, curUid));
218     EXPECT_TRUE(runningLock->IsUsed());
219     runningLock->UnLock();
220     POWER_HILOGD(LABEL_TEST, "RunningLockTest006 end");
221 }
222 
223 /**
224  * @tc.name: RunningLockTest007
225  * @tc.desc: Test ProxyRunningLock function.
226  * @tc.type: FUNC
227  * @tc.require: issueI6S0YY
228  */
HWTEST_F(RunningLockTest, RunningLockTest007, TestSize.Level1)229 HWTEST_F (RunningLockTest, RunningLockTest007, TestSize.Level1)
230 {
231     POWER_HILOGD(LABEL_TEST, "RunningLockTest007 start");
232     auto& powerMgrClient = PowerMgrClient::GetInstance();
233     std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
234         "background.test007", RunningLockType::RUNNINGLOCK_SCREEN);
235     ASSERT_NE(runningLock, nullptr);
236 
237     pid_t curUid = getuid();
238     pid_t curPid = getpid();
239     int32_t timeoutMs = 1000;
240 
241     runningLock->Lock(timeoutMs);
242     EXPECT_TRUE(runningLock->IsUsed());
243 
244     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, curUid));
245     EXPECT_FALSE(runningLock->IsUsed());
246 
247     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, curUid));
248     runningLock->UnLock();
249     EXPECT_FALSE(runningLock->IsUsed());
250     POWER_HILOGD(LABEL_TEST, "RunningLockTest007 end");
251 }
252 
253 /**
254  * @tc.name: RunningLockTest008
255  * @tc.desc: Test ProxyRunningLock function, create runninglock first, then proxy
256  * @tc.type: FUNC
257  * @tc.require: issueI6S0YY
258  */
HWTEST_F(RunningLockTest, RunningLockTest008, TestSize.Level1)259 HWTEST_F (RunningLockTest, RunningLockTest008, TestSize.Level1)
260 {
261     POWER_HILOGD(LABEL_TEST, "RunningLockTest008 start");
262     auto& powerMgrClient = PowerMgrClient::GetInstance();
263 
264     pid_t curUid = getuid();
265     pid_t curPid = getpid();
266     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, curUid));
267 
268     std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
269         "background.test008", RunningLockType::RUNNINGLOCK_BACKGROUND);
270     ASSERT_NE(runningLock, nullptr);
271     runningLock->Lock();
272     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, curUid));
273     runningLock->UnLock();
274     POWER_HILOGD(LABEL_TEST, "RunningLockTest008 end");
275 }
276 
277 /**
278  * @tc.name: RunningLockTest009
279  * @tc.desc: Test ProxyRunningLock function.
280  * @tc.type: FUNC
281  * @tc.require: issueI6S0YY
282  */
HWTEST_F(RunningLockTest, RunningLockTest009, TestSize.Level1)283 HWTEST_F (RunningLockTest, RunningLockTest009, TestSize.Level1)
284 {
285     POWER_HILOGD(LABEL_TEST, "RunningLockTest009 start");
286     auto& powerMgrClient = PowerMgrClient::GetInstance();
287     std::shared_ptr<RunningLock> screenRunningLock = powerMgrClient.CreateRunningLock(
288         "screen.test009", RunningLockType::RUNNINGLOCK_SCREEN);
289     ASSERT_NE(screenRunningLock, nullptr);
290     std::shared_ptr<RunningLock> proximityRunningLock = powerMgrClient.CreateRunningLock(
291         "proximity.test009", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL);
292     ASSERT_NE(proximityRunningLock, nullptr);
293 
294     pid_t curUid = getuid();
295     pid_t curPid = getpid();
296     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, curUid));
297 
298     screenRunningLock->Lock();
299     EXPECT_TRUE(screenRunningLock->IsUsed());
300     screenRunningLock->UnLock();
301 
302     proximityRunningLock->Lock();
303     EXPECT_TRUE(proximityRunningLock->IsUsed());
304     proximityRunningLock->UnLock();
305 
306     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, curUid));
307     POWER_HILOGD(LABEL_TEST, "RunningLockTest009 end");
308 }
309 
310 /**
311  * @tc.name: RunningLockTest010
312  * @tc.desc: Test ProxyRunningLock function, pid is invalid
313  * @tc.type: FUNC
314  * @tc.require: issueI6S0YY
315  */
HWTEST_F(RunningLockTest, RunningLockTest010, TestSize.Level1)316 HWTEST_F (RunningLockTest, RunningLockTest010, TestSize.Level1)
317 {
318     POWER_HILOGD(LABEL_TEST, "RunningLockTest010 start");
319     pid_t curUid = 1;
320     pid_t curPid = -1;
321     auto& powerMgrClient = PowerMgrClient::GetInstance();
322     EXPECT_FALSE(powerMgrClient.ProxyRunningLock(true, curPid, curUid));
323     EXPECT_FALSE(powerMgrClient.ProxyRunningLock(false, curPid, curUid));
324     POWER_HILOGD(LABEL_TEST, "RunningLockTest010 end");
325 }
326 
327 /**
328  * @tc.name: RunningLockTest011
329  * @tc.desc: Test RunningLockProxt AddRunningLock function
330  * @tc.type: FUNC
331  * @tc.require: issueI7405P
332  */
HWTEST_F(RunningLockTest, RunningLockTest011, TestSize.Level1)333 HWTEST_F (RunningLockTest, RunningLockTest011, TestSize.Level1)
334 {
335     POWER_HILOGD(LABEL_TEST, "RunningLockTest011 start");
336     auto runninglockProxy = std::make_shared<RunningLockProxy>();
337     pid_t pid = 1;
338     pid_t uid = -1;
339     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
340     runninglockProxy->AddRunningLock(0, 0, remoteObj);
341     EXPECT_TRUE(runninglockProxy->IncreaseProxyCnt(pid, uid));
342     EXPECT_TRUE(runninglockProxy->DecreaseProxyCnt(pid, uid));
343     POWER_HILOGD(LABEL_TEST, "RunningLockTest011 end");
344 }
345 
346 /**
347  * @tc.name: RunningLockTest012
348  * @tc.desc: Test RunningLockProxt RemoveRunningLock function
349  * @tc.type: FUNC
350  * @tc.require: issueI7405P
351  */
HWTEST_F(RunningLockTest, RunningLockTest012, TestSize.Level1)352 HWTEST_F (RunningLockTest, RunningLockTest012, TestSize.Level1)
353 {
354     POWER_HILOGD(LABEL_TEST, "RunningLockTest012 start");
355     auto runninglockProxy = std::make_shared<RunningLockProxy>();
356     pid_t pid = 1;
357     pid_t uid = -1;
358     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
359     sptr<IRemoteObject> remoteObj2 = nullptr;
360     runninglockProxy->AddRunningLock(pid, uid, remoteObj);
361     runninglockProxy->RemoveRunningLock(pid, uid, remoteObj2);
362     EXPECT_TRUE(runninglockProxy->IncreaseProxyCnt(0, 0));
363     EXPECT_TRUE(runninglockProxy->DecreaseProxyCnt(0, 0));
364     POWER_HILOGD(LABEL_TEST, "RunningLockTest012 end");
365 }
366 
367 /**
368  * @tc.name: RunningLockTest013
369  * @tc.desc: Test RunningLockProxt RemoveRunningLock function
370  * @tc.type: FUNC
371  * @tc.require: issueI7405P
372  */
HWTEST_F(RunningLockTest, RunningLockTest013, TestSize.Level1)373 HWTEST_F (RunningLockTest, RunningLockTest013, TestSize.Level1)
374 {
375     POWER_HILOGD(LABEL_TEST, "RunningLockTest013 start");
376     auto runninglockProxy = std::make_shared<RunningLockProxy>();
377     pid_t pid = 1;
378     pid_t uid = -1;
379     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
380     runninglockProxy->RemoveRunningLock(pid, uid, remoteObj);
381     EXPECT_TRUE(runninglockProxy->IncreaseProxyCnt(pid, uid));
382     POWER_HILOGD(LABEL_TEST, "RunningLockTest013 end");
383 }
384 
385 /**
386  * @tc.name: RunningLockTest014
387  * @tc.desc: Test ProxyRunningLocks function
388  * @tc.type: FUNC
389  * @tc.require: issueI7MNRN
390  */
HWTEST_F(RunningLockTest, RunningLockTest014, TestSize.Level1)391 HWTEST_F(RunningLockTest, RunningLockTest014, TestSize.Level1)
392 {
393     POWER_HILOGD(LABEL_TEST, "RunningLockTest014 start");
394     pid_t curUid = getuid();
395     pid_t curPid = getpid();
396     std::vector<std::pair<pid_t, pid_t>> processInfos;
397     processInfos.push_back(std::pair<pid_t, pid_t>(curPid, curUid));
398     auto& powerMgrClient = PowerMgrClient::GetInstance();
399     EXPECT_TRUE(powerMgrClient.ProxyRunningLocks(true, processInfos));
400     POWER_HILOGD(LABEL_TEST, "RunningLockTest014 end");
401 }
402 
403 /**
404  * @tc.name: RunningLockTest015
405  * @tc.desc: Test Recover function
406  * @tc.type: FUNC
407  * @tc.require:
408  */
HWTEST_F(RunningLockTest, RunningLockTest015, TestSize.Level1)409 HWTEST_F(RunningLockTest, RunningLockTest015, TestSize.Level1)
410 {
411     POWER_HILOGD(LABEL_TEST, "RunningLockTest015 start");
412     auto& powerMgrClient = PowerMgrClient::GetInstance();
413     auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
414     pms->OnStart();
415     auto runningLockMgr = pms->GetRunningLockMgr();
416     sptr<IPowerMgr> ptr;
417     ptr.ForceSetRefPtr(static_cast<IPowerMgr*>(pms.GetRefPtr()));
418     pms.GetRefPtr()->IncStrongRef(pms.GetRefPtr());
419     RunningLock runninglock1(ptr, "runninglock_recover_test", RunningLockType::RUNNINGLOCK_SCREEN);
420     runninglock1.Init();
421     const auto& infos = runningLockMgr->GetRunningLockMap();
422     const auto iter = std::find_if(infos.begin(), infos.end(), [](const auto& pair) {
423         return pair.second->GetName() == "runninglock_recover_test";
424     });
425     EXPECT_TRUE(iter != infos.end());
426     const sptr<IRemoteObject> token = iter->first;
427     runningLockMgr->ReleaseLock(token);
428     EXPECT_TRUE(infos.count(token) == 0);
429     runninglock1.Recover(ptr);
430     EXPECT_TRUE(infos.count(token) > 0);
431     POWER_HILOGD(LABEL_TEST, "RunningLockTest015 end");
432 }
433 
434 /**
435  * @tc.name: RunningLockTest016
436  * @tc.desc: Test ProxyRunningLock function
437  * @tc.type: FUNC
438  * @tc.require
439  */
HWTEST_F(RunningLockTest, RunningLockTest016, TestSize.Level1)440 HWTEST_F (RunningLockTest, RunningLockTest016, TestSize.Level1)
441 {
442     POWER_HILOGD(LABEL_TEST, "RunningLockTest016 start");
443     auto& powerMgrClient = PowerMgrClient::GetInstance();
444 
445     pid_t curUid = getuid();
446     pid_t curPid = getpid();
447 
448     std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
449         "background.test016", RunningLockType::RUNNINGLOCK_BACKGROUND);
450     ASSERT_NE(runningLock, nullptr);
451     runningLock->Lock();
452     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, curUid));
453     EXPECT_FALSE(runningLock->IsUsed());
454     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, curUid));
455     EXPECT_TRUE(runningLock->IsUsed());
456     runningLock->UnLock();
457     POWER_HILOGD(LABEL_TEST, "RunningLockTest016 end");
458 }
459 
460 /**
461  * @tc.name: RunningLockTest017
462  * @tc.desc: Test UpdateWorkSource function
463  * @tc.type: FUNC
464  * @tc.require
465  */
HWTEST_F(RunningLockTest, RunningLockTest017, TestSize.Level1)466 HWTEST_F (RunningLockTest, RunningLockTest017, TestSize.Level1)
467 {
468     POWER_HILOGD(LABEL_TEST, "RunningLockTest017 start");
469     auto& powerMgrClient = PowerMgrClient::GetInstance();
470 
471     pid_t curUid = getuid();
472     pid_t curPid = getpid();
473 
474     std::shared_ptr<RunningLock> runningLock = powerMgrClient.CreateRunningLock(
475         "background.test017", RunningLockType::RUNNINGLOCK_BACKGROUND);
476     ASSERT_NE(runningLock, nullptr);
477     runningLock->Lock();
478     std::vector<int32_t> workSource { 0 };
479     EXPECT_TRUE(runningLock->UpdateWorkSource(workSource) == 0);
480     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(true, curPid, 0));
481     EXPECT_FALSE(runningLock->IsUsed());
482     EXPECT_TRUE(powerMgrClient.ProxyRunningLock(false, curPid, 0));
483     EXPECT_TRUE(runningLock->IsUsed());
484     runningLock->UnLock();
485     POWER_HILOGD(LABEL_TEST, "RunningLockTest017 end");
486 }
487 
488 /**
489  * @tc.name: RunningLockTest018
490  * @tc.desc: Test UpdateWorkSource function
491  * @tc.type: FUNC
492  * @tc.require
493  */
HWTEST_F(RunningLockTest, RunningLockTest018, TestSize.Level1)494 HWTEST_F (RunningLockTest, RunningLockTest018, TestSize.Level1)
495 {
496     POWER_HILOGD(LABEL_TEST, "RunningLockTest018 start");
497     auto runninglockProxy = std::make_shared<RunningLockProxy>();
498     pid_t pid = 1;
499     pid_t uid = -1;
500     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
501     sptr<IRemoteObject> remoteObj2 = nullptr;
502     runninglockProxy->AddRunningLock(pid, uid, remoteObj);
503     runninglockProxy->RemoveRunningLock(pid, uid, remoteObj2);
504 
505     EXPECT_TRUE(runninglockProxy->UpdateWorkSource(pid, uid, remoteObj, {{0, {"test", false}}}));
506     runninglockProxy->RemoveRunningLock(pid, uid, remoteObj);
507     EXPECT_TRUE(runninglockProxy->IncreaseProxyCnt(pid, uid));
508     EXPECT_TRUE(runninglockProxy->DecreaseProxyCnt(pid, uid));
509     POWER_HILOGD(LABEL_TEST, "RunningLockTest018 end");
510 }
511 
512 /**
513  * @tc.name: RunningLockTest019
514  * @tc.desc: Test UpdateWorkSource function
515  * @tc.type: FUNC
516  * @tc.require
517  */
HWTEST_F(RunningLockTest, RunningLockTest019, TestSize.Level1)518 HWTEST_F (RunningLockTest, RunningLockTest019, TestSize.Level1)
519 {
520     POWER_HILOGD(LABEL_TEST, "RunningLockTest019 start");
521     auto runninglockProxy = std::make_shared<RunningLockProxy>();
522     pid_t pid = 1;
523     pid_t uid = -1;
524     sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
525     sptr<IRemoteObject> remoteObj2 = nullptr;
526     runninglockProxy->AddRunningLock(pid, uid, remoteObj);
527     runninglockProxy->RemoveRunningLock(pid, uid, remoteObj2);
528 
529     EXPECT_TRUE(runninglockProxy->UpdateWorkSource(pid, uid, remoteObj, {{0, {"test019", false}}}));
530     EXPECT_TRUE(runninglockProxy->UpdateProxyState(pid, uid, remoteObj, true));
531     EXPECT_TRUE(runninglockProxy->UpdateProxyState(pid, uid, remoteObj, false));
532     runninglockProxy->RemoveRunningLock(pid, uid, remoteObj);
533     EXPECT_TRUE(runninglockProxy->IncreaseProxyCnt(pid, uid));
534     EXPECT_TRUE(runninglockProxy->DecreaseProxyCnt(pid, uid));
535     POWER_HILOGD(LABEL_TEST, "RunningLockTest019 end");
536 }
537 } // namespace