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