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 "thermal_observer_test.h"
17
18 #include <memory>
19 #include <singleton.h>
20 #include <common_event_support.h>
21 #include "iremote_object.h"
22 #include "mock_thermal_remote_object.h"
23 #include "thermal_observer.h"
24 #include "thermal_service.h"
25 #include "thermal_sensor_info.h"
26 #include "charger_state_collection.h"
27 #include "charge_delay_state_collection.h"
28 #include "cust_state_collection.h"
29 #include "startup_delay_state_collection.h"
30 #include "scene_state_collection.h"
31 #include "screen_state_collection.h"
32 #include "state_machine.h"
33
34 #ifdef BATTERY_MANAGER_ENABLE
35 #include "battery_info.h"
36 #include "battery_srv_client.h"
37 #endif
38
39 using namespace testing::ext;
40 using namespace OHOS::PowerMgr;
41 using namespace OHOS;
42 using namespace std;
43 using namespace OHOS::EventFwk;
44
45 namespace {
46 static sptr<ThermalService> g_service = nullptr;
47 }
48
SetUpTestCase()49 void ThermalObserverTest::SetUpTestCase()
50 {
51 g_service = ThermalService::GetInstance();
52 g_service->InitSystemTestModules();
53 g_service->OnStart();
54 }
55
TearDownTestCase()56 void ThermalObserverTest::TearDownTestCase()
57 {
58 g_service->OnStop();
59 }
60
SetUp()61 void ThermalObserverTest::SetUp() {}
62
TearDown()63 void ThermalObserverTest::TearDown() {}
64
HandleScreenOnCompleted(const CommonEventData & data)65 void ThermalObserverTest::HandleScreenOnCompleted(const CommonEventData& data __attribute__((__unused__)))
66 {
67 }
68
69 namespace {
70 /**
71 * @tc.name: ThermalObserverTest001
72 * @tc.desc: Thermal Common Event Receiver Function Test
73 * @tc.type: FUNC
74 */
75 HWTEST_F(ThermalObserverTest, ThermalObserverTest001, TestSize.Level0)
76 {
77 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest001 function start!");
78 EventHandle handlerOn = std::bind(&ThermalObserverTest::HandleScreenOnCompleted, this, std::placeholders::_1);
79 auto receiver = std::make_shared<ThermalCommonEventReceiver>();
80 receiver->AddEvent(CommonEventSupport::COMMON_EVENT_SCREEN_ON, handlerOn);
81 bool on = receiver->Register();
82 EXPECT_TRUE(on);
83 CommonEventData data;
84 receiver->HandleEventChanged(data);
85 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest001 function end!");
86 }
87
88 /**
89 * @tc.name: ThermalObserverTest002
90 * @tc.desc: Thermal Observer Function Test
91 * @tc.type: FUNC
92 */
93 HWTEST_F(ThermalObserverTest, ThermalObserverTest002, TestSize.Level0)
94 {
95 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest002 function start!");
96 auto observer = std::make_shared<ThermalObserver>();
97 std::vector<std::string> typeList;
98 sptr<IThermalTempCallback> tempCallback;
99 observer->Init();
100 observer->SubscribeThermalTempCallback(typeList, tempCallback);
101 // implicit conversion from ThermalTempTestCallback* to IThermalTempCallback* before construct sptr
102 // should be safe to cast back
103 sptr<IThermalTempCallback> tempCb = new ThermalTempTestCallback();
104 observer->SubscribeThermalTempCallback(typeList, tempCb);
105 IThermalTempCallback::TempCallbackMap tempCbMap;
106 EXPECT_CALL(*static_cast<ThermalTempTestCallback*>(tempCb.GetRefPtr()), OnThermalTempChanged(::testing::_));
107 observer->NotifySensorTempChanged(tempCbMap);
108 observer->UnSubscribeThermalTempCallback(tempCb);
109 EXPECT_CALL(*static_cast<ThermalTempTestCallback*>(tempCb.GetRefPtr()), OnThermalTempChanged(::testing::_))
110 .Times(0);
111 observer->NotifySensorTempChanged(tempCbMap);
112 sptr<IThermalActionCallback> actionCb;
113 observer->SubscribeThermalActionCallback(typeList, "desc", actionCb);
114 actionCb = new ThermalActionTestCallback();
115 observer->SubscribeThermalActionCallback(typeList, "desc", actionCb);
116 EXPECT_CALL(*static_cast<ThermalActionTestCallback*>(actionCb.GetRefPtr()), OnThermalActionChanged(::testing::_));
117 observer->SetDecisionValue("", "");
118 observer->FindSubscribeActionValue();
119 observer->UnSubscribeThermalActionCallback(actionCb);
120 IThermalActionCallback::ActionCallbackMap actionCbMap;
121 observer->DecisionActionValue(typeList, actionCbMap);
122 typeList.push_back("cpu_big");
123 typeList.push_back("cpu_med");
124 typeList.push_back("cpu_lit");
125 observer->DecisionActionValue(typeList, actionCbMap);
126 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest002 function end!");
127 }
128
129 /**
130 * @tc.name: ThermalObserverTest003
131 * @tc.desc: Thermal Observer OnRemoteDied Test
132 * @tc.type: FUNC
133 */
134 HWTEST_F(ThermalObserverTest, ThermalObserverTest003, TestSize.Level0)
135 {
136 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest003 function start!");
137 std::shared_ptr<IRemoteObject::DeathRecipient> deathRecipient =
138 std::make_shared<ThermalObserver::SensorTempCallbackDeathRecipient>();
139 wptr<IRemoteObject> remoteObj = nullptr;
140 EXPECT_NE(deathRecipient, nullptr);
141 deathRecipient->OnRemoteDied(remoteObj);
142
143 sptr<IRemoteObject> sptrRemoteObj = new MockThermalRemoteObject();
144 EXPECT_FALSE(sptrRemoteObj == nullptr);
145 deathRecipient->OnRemoteDied(sptrRemoteObj);
146 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest003 function end!");
147 }
148
149 /**
150 * @tc.name: ThermalObserverTest004
151 * @tc.desc: Thermal Observer OnRemoteDied Test
152 * @tc.type: FUNC
153 */
154 HWTEST_F(ThermalObserverTest, ThermalObserverTest004, TestSize.Level0)
155 {
156 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest004 function start!");
157 std::shared_ptr<IRemoteObject::DeathRecipient> deathRecipient =
158 std::make_shared<ThermalObserver::ActionCallbackDeathRecipient>();
159 wptr<IRemoteObject> remoteObj = nullptr;
160 EXPECT_NE(deathRecipient, nullptr);
161 deathRecipient->OnRemoteDied(remoteObj);
162
163 sptr<IRemoteObject> sptrRemoteObj = new MockThermalRemoteObject();
164 EXPECT_FALSE(sptrRemoteObj == nullptr);
165 deathRecipient->OnRemoteDied(sptrRemoteObj);
166 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest004 function end!");
167 }
168
169 /**
170 * @tc.name: ThermalObserverTest005
171 * @tc.desc: Thermal Sensor Info Test
172 * @tc.type: FUNC
173 * @tc.require: issueI6KRS8
174 */
175 HWTEST_F(ThermalObserverTest, ThermalObserverTest005, TestSize.Level0)
176 {
177 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest005 function start!");
178 auto info = std::make_shared<ThermalSensorInfo>();
179 EXPECT_TRUE(info->GetTypeTempMap().empty());
180 TypeTempMap type;
181 info->SetTypeTempMap(type);
182 info->GetTemp("soc");
183 EXPECT_TRUE(info->GetHistoryTemperature("soc").empty());
184 info->NotifyObserver();
185 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest005 function end!");
186 }
187
188 /**
189 * @tc.name: ThermalObserverTest006
190 * @tc.desc: Thermal Charger State Collection Test
191 * @tc.type: FUNC
192 */
193 HWTEST_F(ThermalObserverTest, ThermalObserverTest006, TestSize.Level0)
194 {
195 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest006 function start!");
196 auto chargerState = std::make_shared<ChargerStateCollection>();
197 chargerState->Init();
198 string param = "charging";
199 bool ret = chargerState->InitParam(param);
200 EXPECT_TRUE(ret);
201 chargerState->GetState();
202 chargerState->RegisterEvent();
203 CommonEventData data;
204 chargerState->HandleChangerStatusCompleted(data);
205 chargerState->SetState("");
206 chargerState->DecideState("1");
207 chargerState->HandleChargeIdleState();
208 chargerState->HandleThermalLevelCompleted(data);
209 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest006 function end!");
210 }
211
212 /**
213 * @tc.name: ThermalObserverTest007
214 * @tc.desc: Thermal Scene State Collection Test
215 * @tc.type: FUNC
216 */
217 HWTEST_F(ThermalObserverTest, ThermalObserverTest007, TestSize.Level0)
218 {
219 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest007 function start!");
220 auto sceneState = std::make_shared<SceneStateCollection>();
221 sceneState->Init();
222 string param = "game";
223 bool ret = sceneState->InitParam(param);
224 EXPECT_TRUE(ret);
225 sceneState->SetState("");
226 sceneState->DecideState("game");
227 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest007 function end!");
228 }
229
230 /**
231 * @tc.name: ThermalObserverTest008
232 * @tc.desc: Thermal Screen State Collection Test
233 * @tc.type: FUNC
234 */
235 HWTEST_F(ThermalObserverTest, ThermalObserverTest008, TestSize.Level0)
236 {
237 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest008 function start!");
238 auto screenState = std::make_shared<ScreenStateCollection>();
239 screenState->Init();
240 string param = "on";
241 bool ret = screenState->InitParam(param);
242 EXPECT_TRUE(ret);
243 screenState->GetState();
244 screenState->RegisterEvent();
245 CommonEventData data;
246 screenState->HandleScreenOnCompleted(data);
247 screenState->HandleScreenOffCompleted(data);
248 screenState->SetState("");
249 screenState->DecideState("0");
250 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest008 function end!");
251 }
252
253 /**
254 * @tc.name: ThermalObserverTest009
255 * @tc.desc: Thermal State Machine Test
256 * @tc.type: FUNC
257 */
258 HWTEST_F(ThermalObserverTest, ThermalObserverTest009, TestSize.Level0)
259 {
260 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest009 function start!");
261 auto stateMachine = std::make_shared<StateMachine>();
262 bool ret = stateMachine->Init();
263 EXPECT_TRUE(ret);
264 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest009 function end!");
265 }
266
267 /**
268 * @tc.name: ThermalObserverTest010
269 * @tc.desc: Thermal Charger State Collection Test
270 * @tc.type: FUNC
271 */
272 HWTEST_F(ThermalObserverTest, ThermalObserverTest010, TestSize.Level0)
273 {
274 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest010 function start!");
275 #ifdef BATTERY_MANAGER_ENABLE
276 auto chargerState = std::make_shared<ChargerStateCollection>();
277 CommonEventData data;
278 Want want;
279 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
280 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_DISABLE));
281 data.SetWant(want);
282 chargerState->HandleChangerStatusCompleted(data);
283 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
284 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_ENABLE));
285 data.SetWant(want);
286 chargerState->HandleChangerStatusCompleted(data);
287 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
288 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_FULL));
289 data.SetWant(want);
290 chargerState->HandleChangerStatusCompleted(data);
291 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
292 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_NONE));
293 data.SetWant(want);
294 chargerState->HandleChangerStatusCompleted(data);
295 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
296 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_BUTT));
297 data.SetWant(want);
298 chargerState->HandleChangerStatusCompleted(data);
299 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
300 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_BUTT));
301 data.SetWant(want);
302 chargerState->HandleChangerStatusCompleted(data);
303 if (!g_service->GetSimulationXml()) {
304 EXPECT_EQ(chargerState->GetState(), "");
305 } else {
306 EXPECT_EQ(chargerState->GetState(), ToString(ChargerStateCollection::BUTT));
307 }
308 #endif
309 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest010 function end!");
310 }
311
312 /**
313 * @tc.name: ThermalObserverTest011
314 * @tc.desc: Thermal Charger State Collection Test
315 * @tc.type: FUNC
316 */
317 HWTEST_F(ThermalObserverTest, ThermalObserverTest011, TestSize.Level0)
318 {
319 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest011 function start!");
320 #ifdef BATTERY_MANAGER_ENABLE
321 auto chargerDelayState = std::make_shared<ChargeDelayStateCollection>();
322 auto chargerState = ChargerStateCollection::GetInstance();
323 chargerDelayState->Init();
324 string delayTime = "60000";
325 chargerDelayState->InitParam(delayTime);
326 CommonEventData data;
327 chargerDelayState->HandlerPowerDisconnected(data);
328 EXPECT_EQ(chargerState->GetCharge(), false);
329 EXPECT_EQ(chargerDelayState->GetState(), "0");
330 chargerDelayState->HandlerPowerConnected(data);
331 EXPECT_EQ(chargerState->GetCharge(), true);
332 EXPECT_EQ(chargerDelayState->GetState(), "0");
333 chargerDelayState->HandlerPowerDisconnected(data);
334 EXPECT_EQ(chargerState->GetCharge(), false);
335 EXPECT_EQ(chargerDelayState->GetState(), "1");
336 chargerDelayState->SetState("");
337 chargerDelayState->ResetState();
338
339 #endif
340 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest011 function end!");
341 }
342
343 /**
344 * @tc.name: ThermalObserverTest012
345 * @tc.desc: Thermal Charger State Collection Test
346 * @tc.type: FUNC
347 */
348 HWTEST_F(ThermalObserverTest, ThermalObserverTest012, TestSize.Level0)
349 {
350 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest012 function start!");
351 #ifdef BATTERY_MANAGER_ENABLE
352 auto delayState = std::make_shared<StartupDelayStateCollection>();
353 delayState->Init();
354 EXPECT_EQ(delayState->GetState(), "1");
355 string delayTime = "60000";
356 delayState->InitParam(delayTime);
357 delayState->ResetState();
358 EXPECT_EQ(delayState->GetState(), "0");
359 EXPECT_TRUE(delayState->DecideState("0"));
360 delayState->SetState("");
361 #endif
362 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest012 function end!");
363 }
364
365 /**
366 * @tc.name: ThermalObserverTest013
367 * @tc.desc: Thermal Cust State Collection Test
368 * @tc.type: FUNC
369 */
370 HWTEST_F(ThermalObserverTest, ThermalObserverTest013, TestSize.Level0)
371 {
372 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest013 function start!");
373 auto custState = std::make_shared<CustStateCollection>();
374 custState->Init();
375 string value = "67";
376 custState->SetState(value);
377 EXPECT_TRUE(custState->DecideState("1"));
378 EXPECT_FALSE(custState->DecideState("4"));
379 THERMAL_HILOGI(LABEL_TEST, "ThermalObserverTest013 function end!");
380 }
381 } // namespace
382