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 <bundle_mgr_proxy.h>
17 #include <condition_variable>
18 #include <datetime_ex.h>
19 #include <gtest/gtest.h>
20 #include <if_system_ability_manager.h>
21 #include <iostream>
22 #include <ipc_skeleton.h>
23 #include <mutex>
24 #include <string_ex.h>
25 
26 #include "common_event_manager.h"
27 #include "ipower_mode_callback.h"
28 #include "power_common.h"
29 #include "power_mgr_client.h"
30 #include "power_mgr_powersavemode_test.h"
31 #include "power_mgr_service.h"
32 #include "power_state_machine.h"
33 #include "power_state_machine_info.h"
34 #include "running_lock.h"
35 #include "running_lock_info.h"
36 
37 using namespace testing::ext;
38 using namespace OHOS::PowerMgr;
39 using namespace OHOS::EventFwk;
40 using namespace OHOS;
41 using namespace std;
42 
43 namespace {
44 std::condition_variable g_cv;
45 std::mutex g_mtx;
46 std::string g_action = "";
47 constexpr int64_t TIME_OUT = 1;
48 } // namespace
49 
OnPowerModeChanged(PowerMode mode)50 void PowerMgrPowerSavemodeTest::PowerModeTest1Callback::OnPowerModeChanged(PowerMode mode)
51 {
52     POWER_HILOGD(LABEL_TEST, "PowerModeTest1Callback::OnPowerModeChanged.");
53 }
54 
SetUpTestCase(void)55 void PowerMgrPowerSavemodeTest::SetUpTestCase(void)
56 {
57     auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
58     pms->OnStart();
59     SystemAbility::MakeAndRegisterAbility(pms.GetRefPtr());
60 }
61 
62 namespace {
63 /**
64  * @tc.name: PowerSavemode_001
65  * @tc.desc: test SetDeviceMode in proxy
66  * @tc.type: FUNC
67  * @tc.require: issueI5MJZJ
68  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_001, TestSize.Level2)69 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_001, TestSize.Level2)
70 {
71     GTEST_LOG_(INFO) << "PowerSavemode_001: SetDeviceMode start.";
72     POWER_HILOGD(LABEL_TEST, "PowerSavemode_001 start.");
73 
74     auto& powerMgrClient = PowerMgrClient::GetInstance();
75     PowerMode mode = PowerMode::POWER_SAVE_MODE;
76     PowerMode mode1 = PowerMode::POWER_SAVE_MODE;
77     powerMgrClient.SetDeviceMode(mode);
78     mode = powerMgrClient.GetDeviceMode();
79     EXPECT_EQ(mode, mode1) << "PowerSavemode_001 fail to SetDeviceMode";
80     POWER_HILOGD(LABEL_TEST, "PowerSavemode_001 end.");
81     GTEST_LOG_(INFO) << "PowerSavemode_001: SetDeviceMode end.";
82 }
83 
84 /**
85  * @tc.name: PowerSavemode_002
86  * @tc.desc: test SetDeviceMode in proxy
87  * @tc.type: FUNC
88  * @tc.require: issueI5MJZJ
89  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_002, TestSize.Level2)90 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_002, TestSize.Level2)
91 {
92     GTEST_LOG_(INFO) << "PowerSavemode_002: SetDeviceMode start.";
93     POWER_HILOGD(LABEL_TEST, "PowerSavemode_002 start.");
94     auto& powerMgrClient = PowerMgrClient::GetInstance();
95     PowerMode mode = PowerMode::PERFORMANCE_MODE;
96     PowerMode mode1 = PowerMode::PERFORMANCE_MODE;
97     powerMgrClient.SetDeviceMode(mode);
98     mode = powerMgrClient.GetDeviceMode();
99     EXPECT_EQ(mode, mode1) << "PowerSavemode_002 fail to SetDeviceMode";
100     POWER_HILOGD(LABEL_TEST, "PowerSavemode_002 end.");
101     GTEST_LOG_(INFO) << "PowerSavemode_002: SetDeviceMode end.";
102 }
103 
104 /**
105  * @tc.name: PowerSavemode_003
106  * @tc.desc: test SetDeviceMode in proxy
107  * @tc.type: FUNC
108  * @tc.require: issueI5MJZJ
109  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_003, TestSize.Level2)110 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_003, TestSize.Level2)
111 {
112     GTEST_LOG_(INFO) << "PowerSavemode_003: SetDeviceMode start.";
113     POWER_HILOGD(LABEL_TEST, "PowerSavemode_003 start.");
114     auto& powerMgrClient = PowerMgrClient::GetInstance();
115     PowerMode mode = PowerMode::EXTREME_POWER_SAVE_MODE;
116     PowerMode mode1 = PowerMode::EXTREME_POWER_SAVE_MODE;
117     powerMgrClient.SetDeviceMode(mode);
118     mode = powerMgrClient.GetDeviceMode();
119     EXPECT_EQ(mode, mode1) << "PowerSavemode_003 fail to SetDeviceMode";
120     POWER_HILOGD(LABEL_TEST, "PowerSavemode_003 end.");
121     GTEST_LOG_(INFO) << "PowerSavemode_003: SetDeviceMode end.";
122 }
123 
124 /**
125  * @tc.name: PowerSavemode_004
126  * @tc.desc: test SetDeviceMode in proxy
127  * @tc.type: FUNC
128  * @tc.require: issueI5MJZJ
129  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_004, TestSize.Level2)130 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_004, TestSize.Level2)
131 {
132     GTEST_LOG_(INFO) << "PowerSavemode_004: SetDeviceMode start.";
133     POWER_HILOGD(LABEL_TEST, "PowerSavemode_004 start.");
134     auto& powerMgrClient = PowerMgrClient::GetInstance();
135     PowerMode mode = static_cast<PowerMode>(1);
136     PowerMode mode1 = static_cast<PowerMode>(1);
137     powerMgrClient.SetDeviceMode(mode);
138     mode = powerMgrClient.GetDeviceMode();
139     EXPECT_NE(mode, mode1) << "PowerSavemode_004 fail to SetDeviceMode abnormal";
140     POWER_HILOGD(LABEL_TEST, "PowerSavemode_004 end.");
141     GTEST_LOG_(INFO) << "PowerSavemode_004: SetDeviceMode end.";
142 }
143 
144 /**
145  * @tc.name: PowerSavemode_005
146  * @tc.desc: test SetDeviceMode in proxy
147  * @tc.type: FUNC
148  * @tc.require: issueI5MJZJ
149  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_005, TestSize.Level2)150 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_005, TestSize.Level2)
151 {
152     GTEST_LOG_(INFO) << "PowerSavemode_005: SetDeviceMode start.";
153     POWER_HILOGD(LABEL_TEST, "PowerSavemode_005 start.");
154     auto& powerMgrClient = PowerMgrClient::GetInstance();
155     PowerMode mode = PowerMode::EXTREME_POWER_SAVE_MODE;
156     PowerMode mode1 = PowerMode::EXTREME_POWER_SAVE_MODE;
157     for (int i = 0; i < 100; i++) {
158         powerMgrClient.SetDeviceMode(mode);
159     }
160     mode = powerMgrClient.GetDeviceMode();
161     EXPECT_EQ(mode, mode1) << "PowerSavemode_005 fail to SetDeviceMode";
162     POWER_HILOGD(LABEL_TEST, "PowerSavemode_005 end.");
163     GTEST_LOG_(INFO) << "PowerSavemode_005: SetDeviceMode end.";
164 }
165 
166 /**
167  * @tc.name: PowerSavemode_006
168  * @tc.desc: test GetDeviceMode in proxy
169  * @tc.type: FUNC
170  * @tc.require: issueI5MJZJ
171  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_006, TestSize.Level2)172 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_006, TestSize.Level2)
173 {
174     GTEST_LOG_(INFO) << "PowerSavemode_006: GetDeviceMode start.";
175     POWER_HILOGD(LABEL_TEST, "PowerSavemode_006 start.");
176     auto& powerMgrClient = PowerMgrClient::GetInstance();
177     PowerMode mode = static_cast<PowerMode>(0);
178     PowerMode mode1 = PowerMode::NORMAL_MODE;
179     mode = powerMgrClient.GetDeviceMode();
180     EXPECT_NE(mode, mode1) << "PowerSavemode_006 fail to GetDeviceMode";
181     POWER_HILOGD(LABEL_TEST, "PowerSavemode_006 end.");
182     GTEST_LOG_(INFO) << "PowerSavemode_006: GetDeviceMode end.";
183 }
184 
185 /**
186  * @tc.name: PowerSavemode_007
187  * @tc.desc: test GetDeviceMode in proxy
188  * @tc.type: FUNC
189  * @tc.require: issueI5MJZJ
190  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_007, TestSize.Level2)191 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_007, TestSize.Level2)
192 {
193     GTEST_LOG_(INFO) << "PowerSavemode_007: GetDeviceMode start.";
194     POWER_HILOGD(LABEL_TEST, "PowerSavemode_007 start.");
195     auto& powerMgrClient = PowerMgrClient::GetInstance();
196     PowerMode mode = PowerMode::POWER_SAVE_MODE;
197     PowerMode mode1 = PowerMode::POWER_SAVE_MODE;
198     powerMgrClient.SetDeviceMode(mode);
199     for (int i = 0; i < 100; i++) {
200         mode = powerMgrClient.GetDeviceMode();
201     }
202     EXPECT_EQ(mode, mode1) << "PowerSavemode_007 fail to GetDeviceMode";
203     POWER_HILOGD(LABEL_TEST, "PowerSavemode_007 start.");
204     GTEST_LOG_(INFO) << "PowerSavemode_007: GetDeviceMode end.";
205 }
206 
207 /**
208  * @tc.name: PowerSavemode_008
209  * @tc.desc: test PowerModeCallback
210  * @tc.type: FUNC
211  * @tc.require: issueI5MJZJ
212  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_008, TestSize.Level0)213 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_008, TestSize.Level0)
214 {
215     GTEST_LOG_(INFO) << "PowerSavemode_008: RegisterPowerModeCallback start.";
216     POWER_HILOGD(LABEL_TEST, "PowerSavemode_008 start.");
217     auto& powerMgrClient = PowerMgrClient::GetInstance();
218     const sptr<IPowerModeCallback> cb1 = new PowerModeTest1Callback();
219     powerMgrClient.RegisterPowerModeCallback(cb1);
220     PowerMode mode = PowerMode::POWER_SAVE_MODE;
221     PowerMode mode1 = PowerMode::POWER_SAVE_MODE;
222     powerMgrClient.SetDeviceMode(mode);
223     mode = powerMgrClient.GetDeviceMode();
224     EXPECT_EQ(mode, mode1) << "PowerSavemode_008 fail to PowerModeCallback";
225     POWER_HILOGD(LABEL_TEST, "PowerSavemode_008 end.");
226     GTEST_LOG_(INFO) << "PowerSavemode_008: RegisterPowerModeCallback end.";
227 }
228 
229 /**
230  * @tc.name: PowerSavemode_009
231  * @tc.desc: test PowerModeCallback
232  * @tc.type: FUNC
233  * @tc.require: issueI5MJZJ
234  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_009, TestSize.Level0)235 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_009, TestSize.Level0)
236 {
237     GTEST_LOG_(INFO) << "PowerSavemode_009: RegisterPowerModeCallback start.";
238     POWER_HILOGD(LABEL_TEST, "PowerSavemode_009 Start.");
239     auto& powerMgrClient = PowerMgrClient::GetInstance();
240     const sptr<IPowerModeCallback> cb1 = new PowerModeTest1Callback();
241     powerMgrClient.RegisterPowerModeCallback(cb1);
242 
243     PowerMode mode = static_cast<PowerMode>(1);
244     PowerMode mode1 = static_cast<PowerMode>(1);
245     powerMgrClient.SetDeviceMode(mode);
246     mode = powerMgrClient.GetDeviceMode();
247     EXPECT_NE(mode, mode1) << "PowerSavemode_009 fail to PowerModeCallback";
248     POWER_HILOGD(LABEL_TEST, "PowerSavemode_009 end.");
249     GTEST_LOG_(INFO) << "PowerSavemode_009: RegisterPowerModeCallback end.";
250 }
251 
252 /**
253  * @tc.name: PowerSavemode_010
254  * @tc.desc: test PowerModeCallback
255  * @tc.type: FUNC
256  * @tc.require: issueI5MJZJ
257  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_010, TestSize.Level0)258 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_010, TestSize.Level0)
259 {
260     GTEST_LOG_(INFO) << "PowerSavemode_010: RegisterPowerModeCallback start.";
261     POWER_HILOGD(LABEL_TEST, "PowerSavemode_010 start.");
262     auto& powerMgrClient = PowerMgrClient::GetInstance();
263     const sptr<IPowerModeCallback> cb1 = new PowerModeTest1Callback();
264     for (int i = 0; i < 100; i++) {
265         powerMgrClient.RegisterPowerModeCallback(cb1);
266     }
267     PowerMode mode = PowerMode::POWER_SAVE_MODE;
268     PowerMode mode1 = PowerMode::POWER_SAVE_MODE;
269     powerMgrClient.SetDeviceMode(mode);
270     mode = powerMgrClient.GetDeviceMode();
271     EXPECT_EQ(mode, mode1) << "PowerSavemode_010 fail to PowerModeCallback";
272     POWER_HILOGD(LABEL_TEST, "PowerSavemode_010 end.");
273     GTEST_LOG_(INFO) << "PowerSavemode_010: RegisterPowerModeCallback end.";
274 }
275 
276 /**
277  * @tc.name: PowerSavemode_011
278  * @tc.desc: test PowerModeCallback
279  * @tc.type: FUNC
280  * @tc.require: issueI5MJZJ
281  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_011, TestSize.Level0)282 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_011, TestSize.Level0)
283 {
284     GTEST_LOG_(INFO) << "PowerSavemode_011: UnRegisterPowerModeCallback start.";
285     POWER_HILOGD(LABEL_TEST, "PowerSavemode_011 start.");
286     auto& powerMgrClient = PowerMgrClient::GetInstance();
287     const sptr<IPowerModeCallback> cb1 = new PowerModeTest1Callback();
288     powerMgrClient.UnRegisterPowerModeCallback(cb1);
289     PowerMode mode = PowerMode::POWER_SAVE_MODE;
290     PowerMode mode1 = PowerMode::POWER_SAVE_MODE;
291     powerMgrClient.SetDeviceMode(mode);
292     mode = powerMgrClient.GetDeviceMode();
293     EXPECT_EQ(mode, mode1) << "PowerSavemode_011 fail to PowerModeCallback";
294     POWER_HILOGD(LABEL_TEST, "PowerSavemode_011 end.");
295     GTEST_LOG_(INFO) << "PowerSavemode_011: UnRegisterPowerModeCallback end.";
296 }
297 
298 /**
299  * @tc.name: PowerSavemode_012
300  * @tc.desc: test PowerModeCallback
301  * @tc.type: FUNC
302  * @tc.require: issueI5MJZJ
303  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_012, TestSize.Level0)304 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_012, TestSize.Level0)
305 {
306     GTEST_LOG_(INFO) << "PowerSavemode_012: UnRegisterPowerModeCallback start.";
307     POWER_HILOGD(LABEL_TEST, "PowerSavemode_012 UnRegisterPowerModeCallback start.");
308     auto& powerMgrClient = PowerMgrClient::GetInstance();
309     const sptr<IPowerModeCallback> cb1 = new PowerModeTest1Callback();
310     powerMgrClient.UnRegisterPowerModeCallback(cb1);
311     PowerMode mode = static_cast<PowerMode>(1);
312     PowerMode mode1 = static_cast<PowerMode>(1);
313     powerMgrClient.SetDeviceMode(mode);
314     mode = powerMgrClient.GetDeviceMode();
315     EXPECT_NE(mode, mode1) << "PowerSavemode_012 fail to PowerModeCallback";
316     POWER_HILOGD(LABEL_TEST, "PowerSavemode_012 UnRegisterPowerModeCallback end.");
317     GTEST_LOG_(INFO) << "PowerSavemode_012: UnRegisterPowerModeCallback end.";
318 }
319 
320 /**
321  * @tc.name: PowerSavemode_013
322  * @tc.desc: test PowerModeCallback
323  * @tc.type: FUNC
324  * @tc.require: issueI5MJZJ
325  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_013, TestSize.Level0)326 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_013, TestSize.Level0)
327 {
328     GTEST_LOG_(INFO) << "PowerSavemode_013: UnRegisterPowerModeCallback start.";
329     POWER_HILOGD(LABEL_TEST, "PowerSavemode_013 start.");
330     auto& powerMgrClient = PowerMgrClient::GetInstance();
331     const sptr<IPowerModeCallback> cb1 = new PowerModeTest1Callback();
332     for (int i = 0; i < 100; i++) {
333         powerMgrClient.UnRegisterPowerModeCallback(cb1);
334     }
335 
336     PowerMode mode = PowerMode::POWER_SAVE_MODE;
337     PowerMode mode1 = PowerMode::POWER_SAVE_MODE;
338     powerMgrClient.SetDeviceMode(mode);
339     mode = powerMgrClient.GetDeviceMode();
340     EXPECT_EQ(mode, mode1) << "PowerSavemode_013 fail to PowerModeCallback";
341     POWER_HILOGD(LABEL_TEST, "PowerSavemode_013 end.");
342     GTEST_LOG_(INFO) << "PowerSavemode_013: UnRegisterPowerModeCallback end.";
343 }
344 } // namespace
345 
CommonEventServiCesSystemTest( const CommonEventSubscribeInfo& subscriberInfo)346 PowerMgrPowerSavemodeTest::CommonEventServiCesSystemTest::CommonEventServiCesSystemTest(
347     const CommonEventSubscribeInfo& subscriberInfo) : CommonEventSubscriber(subscriberInfo)
348 {
349     POWER_HILOGD(LABEL_TEST, "subscribe.");
350 }
351 
352 static uint32_t g_i = 0;
353 static int g_judgeNum = 2;
354 
OnReceiveEvent(const CommonEventData& data)355 void PowerMgrPowerSavemodeTest::CommonEventServiCesSystemTest::OnReceiveEvent(const CommonEventData& data)
356 {
357     std::string action = data.GetWant().GetAction();
358     if (action == CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED) {
359         POWER_HILOGD(LABEL_TEST, "CommonEventServiCesSystemTest::OnReceiveEvent.");
360         g_i = g_judgeNum;
361     }
362     uint32_t j = 2;
363     EXPECT_EQ(g_i, j) << "PowerSavemode_022 fail to PowerModeCallback";
364     POWER_HILOGD(LABEL_TEST, "CommonEventServiCesSystemTest::OnReceiveEvent other.");
365 }
366 
367 class CommonEventSaveModeTest : public EventFwk::CommonEventSubscriber {
368 public:
369     CommonEventSaveModeTest() = default;
370     explicit CommonEventSaveModeTest(const EventFwk::CommonEventSubscribeInfo& subscriberInfo);
~CommonEventSaveModeTest()371     virtual ~CommonEventSaveModeTest() {};
372     virtual void OnReceiveEvent(const EventFwk::CommonEventData& data);
373     static shared_ptr<CommonEventSaveModeTest> RegisterEvent();
374 };
375 
CommonEventSaveModeTest(const CommonEventSubscribeInfo& subscriberInfo)376 CommonEventSaveModeTest::CommonEventSaveModeTest(const CommonEventSubscribeInfo& subscriberInfo)
377     : CommonEventSubscriber(subscriberInfo)
378 {
379 }
380 
OnReceiveEvent(const CommonEventData& data)381 void CommonEventSaveModeTest::OnReceiveEvent(const CommonEventData& data)
382 {
383     g_action = data.GetWant().GetAction();
384     g_cv.notify_one();
385 }
386 
RegisterEvent()387 shared_ptr<CommonEventSaveModeTest> CommonEventSaveModeTest::RegisterEvent()
388 {
389     int32_t retryTimes = 2;
390     bool succeed = false;
391     MatchingSkills matchingSkills;
392     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED);
393     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
394     auto subscriberPtr = std::make_shared<CommonEventSaveModeTest>(subscribeInfo);
395     for (int32_t tryTimes = 0; tryTimes < retryTimes; tryTimes++) {
396         succeed = CommonEventManager::SubscribeCommonEvent(subscriberPtr);
397     }
398     if (!succeed) {
399         return nullptr;
400     }
401     return subscriberPtr;
402 }
403 
404 namespace {
405 /**
406  * @tc.name: PowerSavemode_014
407  * @tc.desc: ReceiveEvent
408  * @tc.type: FUNC
409  * @tc.require: issueI5MJZJ
410  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_014, TestSize.Level0)411 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_014, TestSize.Level0)
412 {
413     GTEST_LOG_(INFO) << "PowerSavemode_014: UnRegisterPowerModeCallback start.";
414     POWER_HILOGD(LABEL_TEST, "PowerSavemode_014 UnRegisterPowerModeCallback start.");
415     bool result = false;
416     MatchingSkills matchingSkills;
417     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED);
418     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
419     auto subscriberPtr = std::make_shared<CommonEventServiCesSystemTest>(subscribeInfo);
420     result = CommonEventManager::SubscribeCommonEvent(subscriberPtr);
421     EXPECT_TRUE(result);
422     auto& powerMgrClient = PowerMgrClient::GetInstance();
423     PowerMode mode = PowerMode::PERFORMANCE_MODE;
424     powerMgrClient.SetDeviceMode(mode);
425     CommonEventManager::UnSubscribeCommonEvent(subscriberPtr);
426 
427     POWER_HILOGD(LABEL_TEST, "PowerSavemode_014 UnRegisterPowerModeCallback end.");
428     GTEST_LOG_(INFO) << "PowerSavemode_014: UnRegisterPowerModeCallback end.";
429 }
430 
431 /**
432  * @tc.name: PowerSavemode_015
433  * @tc.desc: ReceiveEvent
434  * @tc.type: FUNC
435  * @tc.require: issueI5MJZJ
436  */
HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_015, TestSize.Level0)437 HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_015, TestSize.Level0)
438 {
439     GTEST_LOG_(INFO) << "PowerSavemode_015: UnRegisterPowerModeCallback start.";
440     POWER_HILOGD(LABEL_TEST, "PowerSavemode_015 start.");
441     bool result = false;
442     MatchingSkills matchingSkills;
443     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED);
444     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
445     auto subscriberPtr = std::make_shared<CommonEventServiCesSystemTest>(subscribeInfo);
446     result = CommonEventManager::SubscribeCommonEvent(subscriberPtr);
447     EXPECT_TRUE(result);
448     auto& powerMgrClient = PowerMgrClient::GetInstance();
449     PowerMode mode = PowerMode::EXTREME_POWER_SAVE_MODE;
450     powerMgrClient.SetDeviceMode(mode);
451     CommonEventManager::UnSubscribeCommonEvent(subscriberPtr);
452     POWER_HILOGD(LABEL_TEST, "PowerSavemode_015 end.");
453     GTEST_LOG_(INFO) << "PowerSavemode_015: UnRegisterPowerModeCallback start.";
454 }
455 
456 } // namespace