1 /*
2 * Copyright (c) 2023 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 "sync_shutdown_callback_test.h"
17
18 #include <condition_variable>
19
20 #include "power_log.h"
21 #include "power_mgr_client.h"
22 #include "power_mgr_service.h"
23 #include "shutdown/shutdown_client.h"
24
25 #include "mock_power_action.h"
26 #include "mock_state_action.h"
27
28 namespace OHOS {
29 namespace PowerMgr {
30 namespace UnitTest {
31 namespace {
32 sptr<PowerMgrService> g_service = nullptr;
33 MockPowerAction* g_mockPowerAction = nullptr;
34 MockStateAction* g_mockStateAction = nullptr;
35 bool g_isHighPriority = false;
36 bool g_isDefaultPriority = false;
37 bool g_isLowPriority = false;
38 }
39 using namespace testing::ext;
40
SetUpTestCase()41 void SyncShutdownCallbackTest::SetUpTestCase()
42 {
43 // create singleton service object at the beginning
44 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
45 g_service->OnStart();
46 }
47
TearDownTestCase()48 void SyncShutdownCallbackTest::TearDownTestCase()
49 {
50 g_service->OnStop();
51 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
52 }
53
SetUp()54 void SyncShutdownCallbackTest::SetUp()
55 {
56 g_isHighPriority = false;
57 g_isDefaultPriority = false;
58 g_isLowPriority = false;
59 g_mockPowerAction = new MockPowerAction();
60 g_mockStateAction = new MockStateAction();
61 auto shutdownController = g_service->GetShutdownController();
62 shutdownController->EnableMock(g_mockPowerAction, g_mockStateAction);
63 }
64
TearDown()65 void SyncShutdownCallbackTest::TearDown()
66 {}
67
OnSyncShutdown()68 void SyncShutdownCallbackTest::SyncShutdownCallback::OnSyncShutdown()
69 {
70 g_isDefaultPriority = true;
71 }
72
OnSyncShutdown()73 void SyncShutdownCallbackTest::HighPrioritySyncShutdownCallback::OnSyncShutdown()
74 {
75 g_isHighPriority = true;
76 }
77
OnSyncShutdown()78 void SyncShutdownCallbackTest::LowPrioritySyncShutdownCallback::OnSyncShutdown()
79 {
80 g_isLowPriority = true;
81 }
82
OnSyncShutdown()83 void SyncShutdownCallbackTest::NotSyncShutdownCallback::OnSyncShutdown()
84 {
85 }
86
OnSyncShutdownOrReboot(bool isReboot)87 void SyncShutdownCallbackTest::SyncShutdownOrRebootCallback::OnSyncShutdownOrReboot(bool isReboot)
88 {
89 g_isDefaultPriority = true;
90 }
91
OnSyncShutdownOrReboot(bool isReboot)92 void SyncShutdownCallbackTest::HighPrioritySyncShutdownOrRebootCallback::OnSyncShutdownOrReboot(bool isReboot)
93 {
94 g_isHighPriority = true;
95 }
96
OnSyncShutdownOrReboot(bool isReboot)97 void SyncShutdownCallbackTest::LowPrioritySyncShutdownOrRebootCallback::OnSyncShutdownOrReboot(bool isReboot)
98 {
99 g_isLowPriority = true;
100 }
101
OnSyncShutdownOrReboot(bool isReboot)102 void SyncShutdownCallbackTest::NotSyncShutdownOrRebootCallback::OnSyncShutdownOrReboot(bool isReboot)
103 {
104 }
105
106 /**
107 * @tc.name: SyncShutdownCallbackk001
108 * @tc.desc: Test synchronous shutdown callback for shutdown and reboot
109 * @tc.type: FUNC
110 */
111 HWTEST_F(SyncShutdownCallbackTest, SyncShutdownCallbackk001, TestSize.Level0)
112 {
113 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackk001 start");
114 auto callback = new SyncShutdownCallback();
115 g_service->RegisterShutdownCallback(callback, ShutdownPriority::DEFAULT);
116
117 auto callback2 = new SyncShutdownOrRebootCallback();
118 g_service->RegisterShutdownCallback(callback2, ShutdownPriority::DEFAULT);
119
120 g_service->RebootDevice("test_reboot");
121 EXPECT_TRUE(g_isDefaultPriority);
122
123 g_service->ShutDownDevice("test_shutdown");
124 EXPECT_TRUE(g_isDefaultPriority);
125 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallback001 end");
126 }
127
128 /**
129 * @tc.name: SyncShutdownCallbackk002
130 * @tc.desc: Test the low and default priority of synchronous shutdown callback
131 * @tc.type: FUNC
132 */
133 HWTEST_F(SyncShutdownCallbackTest, SyncShutdownCallbackk002, TestSize.Level0)
134 {
135 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackk002 start");
136 auto lowPriorityCallback = new LowPrioritySyncShutdownCallback();
137 g_service->RegisterShutdownCallback(lowPriorityCallback, ShutdownPriority::LOW);
138 auto defaultPriorityCallback = new SyncShutdownCallback();
139 g_service->RegisterShutdownCallback(defaultPriorityCallback, ShutdownPriority::DEFAULT);
140
141 g_service->ShutDownDevice("test_shutdown");
142 EXPECT_TRUE(g_isDefaultPriority);
143 EXPECT_TRUE(g_isLowPriority);
144 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackk002 end");
145 }
146
147 /**
148 * @tc.name: SyncShutdownCallbackk003
149 * @tc.desc: Test the low and high priority of synchronous shutdown callback
150 * @tc.type: FUNC
151 */
152 HWTEST_F(SyncShutdownCallbackTest, SyncShutdownCallbackk003, TestSize.Level0)
153 {
154 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackk003 start");
155 auto lowPriorityCallback = new LowPrioritySyncShutdownCallback();
156 g_service->RegisterShutdownCallback(lowPriorityCallback, ShutdownPriority::LOW);
157 auto highPriorityCallback = new HighPrioritySyncShutdownCallback();
158 g_service->RegisterShutdownCallback(highPriorityCallback, ShutdownPriority::HIGH);
159
160 g_service->ShutDownDevice("test_shutdown");
161 EXPECT_TRUE(g_isHighPriority);
162 EXPECT_TRUE(g_isLowPriority);
163 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallbackk003 end");
164 }
165
166 /**
167 * @tc.name: SyncShutdownCallback004
168 * @tc.desc: Test the default and high priority of synchronous shutdown callback
169 * @tc.type: FUNC
170 */
171 HWTEST_F(SyncShutdownCallbackTest, SyncShutdownCallback004, TestSize.Level0)
172 {
173 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallback004 start");
174 auto defaultPriorityCallback = new SyncShutdownCallback();
175 g_service->RegisterShutdownCallback(defaultPriorityCallback, ShutdownPriority::DEFAULT);
176 auto highPriorityCallback = new HighPrioritySyncShutdownCallback();
177 g_service->RegisterShutdownCallback(highPriorityCallback, ShutdownPriority::HIGH);
178
179 g_service->ShutDownDevice("test_shutdown");
180 EXPECT_TRUE(g_isHighPriority);
181 EXPECT_TRUE(g_isDefaultPriority);
182 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallback004 end");
183 }
184
185 /**
186 * @tc.name: SyncShutdownCallback005
187 * @tc.desc: Test do not synchronous shutdown
188 * @tc.type: FUNC
189 */
190 HWTEST_F(SyncShutdownCallbackTest, SyncShutdownCallback005, TestSize.Level0)
191 {
192 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallback005 start");
193 auto notSyncCallback = new NotSyncShutdownCallback();
194 g_service->RegisterShutdownCallback(notSyncCallback, ShutdownPriority::DEFAULT);
195
196 EXPECT_CALL(*g_mockPowerAction, Reboot(std::string("test_reboot"))).Times(1);
197 g_service->RebootDevice("test_reboot");
198
199 EXPECT_CALL(*g_mockPowerAction, Shutdown(std::string("test_shutdown"))).Times(1);
200 g_service->ShutDownDevice("test_shutdown");
201 POWER_HILOGI(LABEL_TEST, "SyncShutdownCallback005 end");
202 }
203 } // namespace UnitTest
204 } // namespace PowerMgr
205 } // namespace OHOS
206