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 "scene_state_collection.h"
28 #include "screen_state_collection.h"
29 #include "state_machine.h"
30
31 #ifdef BATTERY_MANAGER_ENABLE
32 #include "battery_info.h"
33 #include "battery_srv_client.h"
34 #endif
35
36 using namespace testing::ext;
37 using namespace OHOS::PowerMgr;
38 using namespace OHOS;
39 using namespace std;
40 using namespace OHOS::EventFwk;
41
42 namespace {
43 static sptr<ThermalService> g_service = nullptr;
44 }
45
SetUpTestCase()46 void ThermalObserverTest::SetUpTestCase()
47 {
48 g_service = ThermalService::GetInstance();
49 g_service->InitSystemTestModules();
50 g_service->OnStart();
51 }
52
TearDownTestCase()53 void ThermalObserverTest::TearDownTestCase()
54 {
55 g_service->OnStop();
56 }
57
SetUp()58 void ThermalObserverTest::SetUp() {}
59
TearDown()60 void ThermalObserverTest::TearDown() {}
61
HandleScreenOnCompleted(const CommonEventData & data)62 void ThermalObserverTest::HandleScreenOnCompleted(const CommonEventData& data __attribute__((__unused__)))
63 {
64 }
65
OnThermalTempChanged(TempCallbackMap & tempCbMap)66 bool ThermalObserverTest::ThermalTempTestCallback::OnThermalTempChanged(TempCallbackMap& tempCbMap)
67 {
68 return true;
69 }
70
OnThermalActionChanged(ActionCallbackMap & actionCbMap)71 bool ThermalObserverTest::ThermalActionTestCallback::OnThermalActionChanged(ActionCallbackMap& actionCbMap)
72 {
73 return true;
74 }
75
76 namespace {
77 /**
78 * @tc.name: ThermalObserverTest001
79 * @tc.desc: Thermal Common Event Receiver Function Test
80 * @tc.type: FUNC
81 */
82 HWTEST_F(ThermalObserverTest, ThermalObserverTest001, TestSize.Level0)
83 {
84 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest001 start");
85 EventHandle handlerOn = std::bind(&ThermalObserverTest::HandleScreenOnCompleted, this, std::placeholders::_1);
86 auto receiver = std::make_shared<ThermalCommonEventReceiver>();
87 receiver->AddEvent(CommonEventSupport::COMMON_EVENT_SCREEN_ON, handlerOn);
88 bool on = receiver->Register();
89 EXPECT_TRUE(on);
90 CommonEventData data;
91 receiver->HandleEventChanged(data);
92 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest001 end");
93 }
94
95 /**
96 * @tc.name: ThermalObserverTest002
97 * @tc.desc: Thermal Observer Function Test
98 * @tc.type: FUNC
99 */
100 HWTEST_F(ThermalObserverTest, ThermalObserverTest002, TestSize.Level0)
101 {
102 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest002 start");
103 auto observer = std::make_shared<ThermalObserver>();
104 std::vector<std::string> typeList;
105 sptr<IThermalTempCallback> tempCallback;
106 observer->Init();
107 observer->SubscribeThermalTempCallback(typeList, tempCallback);
108 sptr<IThermalTempCallback> tempCb = new ThermalTempTestCallback();
109 observer->SubscribeThermalTempCallback(typeList, tempCb);
110 observer->UnSubscribeThermalTempCallback(tempCb);
111 sptr<IThermalActionCallback> actionCb;
112 observer->SubscribeThermalActionCallback(typeList, "desc", actionCb);
113 actionCb = new ThermalActionTestCallback();
114 observer->SubscribeThermalActionCallback(typeList, "desc", actionCb);
115 observer->FindSubscribeActionValue();
116 observer->UnSubscribeThermalActionCallback(actionCb);
117 IThermalActionCallback::ActionCallbackMap actionCbMap;
118 observer->DecisionActionValue(typeList, actionCbMap);
119 typeList.push_back("cpu_big");
120 typeList.push_back("cpu_med");
121 typeList.push_back("cpu_lit");
122 observer->DecisionActionValue(typeList, actionCbMap);
123 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest002 end");
124 }
125
126 /**
127 * @tc.name: ThermalObserverTest003
128 * @tc.desc: Thermal Observer OnRemoteDied Test
129 * @tc.type: FUNC
130 */
131 HWTEST_F(ThermalObserverTest, ThermalObserverTest003, TestSize.Level0)
132 {
133 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest003 start");
134 std::shared_ptr<IRemoteObject::DeathRecipient> deathRecipient =
135 std::make_shared<ThermalObserver::SensorTempCallbackDeathRecipient>();
136 wptr<IRemoteObject> remoteObj = nullptr;
137 EXPECT_NE(deathRecipient, nullptr);
138 deathRecipient->OnRemoteDied(remoteObj);
139
140 sptr<IRemoteObject> sptrRemoteObj = new MockThermalRemoteObject();
141 EXPECT_FALSE(sptrRemoteObj == nullptr);
142 deathRecipient->OnRemoteDied(sptrRemoteObj);
143 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest003 end");
144 }
145
146 /**
147 * @tc.name: ThermalObserverTest004
148 * @tc.desc: Thermal Observer OnRemoteDied Test
149 * @tc.type: FUNC
150 */
151 HWTEST_F(ThermalObserverTest, ThermalObserverTest004, TestSize.Level0)
152 {
153 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest004 start");
154 std::shared_ptr<IRemoteObject::DeathRecipient> deathRecipient =
155 std::make_shared<ThermalObserver::ActionCallbackDeathRecipient>();
156 wptr<IRemoteObject> remoteObj = nullptr;
157 EXPECT_NE(deathRecipient, nullptr);
158 deathRecipient->OnRemoteDied(remoteObj);
159
160 sptr<IRemoteObject> sptrRemoteObj = new MockThermalRemoteObject();
161 EXPECT_FALSE(sptrRemoteObj == nullptr);
162 deathRecipient->OnRemoteDied(sptrRemoteObj);
163 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest004 end");
164 }
165
166 /**
167 * @tc.name: ThermalObserverTest005
168 * @tc.desc: Thermal Sensor Info Test
169 * @tc.type: FUNC
170 * @tc.require: issueI6KRS8
171 */
172 HWTEST_F(ThermalObserverTest, ThermalObserverTest005, TestSize.Level0)
173 {
174 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest005 start");
175 auto info = std::make_shared<ThermalSensorInfo>();
176 EXPECT_TRUE(info->GetTypeTempMap().empty());
177 TypeTempMap type;
178 info->SetTypeTempMap(type);
179 info->GetTemp("soc");
180 EXPECT_TRUE(info->GetHistoryTemperature("soc").empty());
181 info->NotifyObserver();
182 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest005 end");
183 }
184
185 /**
186 * @tc.name: ThermalObserverTest006
187 * @tc.desc: Thermal Charger State Collection Test
188 * @tc.type: FUNC
189 */
190 HWTEST_F(ThermalObserverTest, ThermalObserverTest006, TestSize.Level0)
191 {
192 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest006 start");
193 auto chargerState = std::make_shared<ChargerStateCollection>();
194 chargerState->Init();
195 string param = "charging";
196 bool ret = chargerState->InitParam(param);
197 EXPECT_TRUE(ret);
198 chargerState->GetState();
199 chargerState->RegisterEvent();
200 CommonEventData data;
201 chargerState->HandleChangerStatusCompleted(data);
202 chargerState->SetState("");
203 chargerState->DecideState("1");
204 chargerState->HandleChargeIdleState();
205 chargerState->HandleThermalLevelCompleted(data);
206 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest006 end");
207 }
208
209 /**
210 * @tc.name: ThermalObserverTest007
211 * @tc.desc: Thermal Scene State Collection Test
212 * @tc.type: FUNC
213 */
214 HWTEST_F(ThermalObserverTest, ThermalObserverTest007, TestSize.Level0)
215 {
216 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest007 start");
217 auto sceneState = std::make_shared<SceneStateCollection>();
218 sceneState->Init();
219 string param = "game";
220 bool ret = sceneState->InitParam(param);
221 EXPECT_TRUE(ret);
222 sceneState->SetState("");
223 sceneState->DecideState("game");
224 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest007 end");
225 }
226
227 /**
228 * @tc.name: ThermalObserverTest008
229 * @tc.desc: Thermal Screen State Collection Test
230 * @tc.type: FUNC
231 */
232 HWTEST_F(ThermalObserverTest, ThermalObserverTest008, TestSize.Level0)
233 {
234 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest008 start");
235 auto screenState = std::make_shared<ScreenStateCollection>();
236 screenState->Init();
237 string param = "on";
238 bool ret = screenState->InitParam(param);
239 EXPECT_TRUE(ret);
240 screenState->GetState();
241 screenState->RegisterEvent();
242 CommonEventData data;
243 screenState->HandleScreenOnCompleted(data);
244 screenState->HandleScreenOffCompleted(data);
245 screenState->SetState("");
246 screenState->DecideState("0");
247 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest008 end");
248 }
249
250 /**
251 * @tc.name: ThermalObserverTest009
252 * @tc.desc: Thermal State Machine Test
253 * @tc.type: FUNC
254 */
255 HWTEST_F(ThermalObserverTest, ThermalObserverTest009, TestSize.Level0)
256 {
257 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest009 start");
258 auto stateMachine = std::make_shared<StateMachine>();
259 bool ret = stateMachine->Init();
260 EXPECT_TRUE(ret);
261 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest009 end");
262 }
263
264 /**
265 * @tc.name: ThermalObserverTest010
266 * @tc.desc: Thermal Charger State Collection Test
267 * @tc.type: FUNC
268 */
269 HWTEST_F(ThermalObserverTest, ThermalObserverTest010, TestSize.Level0)
270 {
271 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest010 start");
272 #ifdef BATTERY_MANAGER_ENABLE
273 auto chargerState = std::make_shared<ChargerStateCollection>();
274 CommonEventData data;
275 Want want;
276 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
277 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_DISABLE));
278 data.SetWant(want);
279 chargerState->HandleChangerStatusCompleted(data);
280 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
281 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_ENABLE));
282 data.SetWant(want);
283 chargerState->HandleChangerStatusCompleted(data);
284 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
285 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_FULL));
286 data.SetWant(want);
287 chargerState->HandleChangerStatusCompleted(data);
288 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
289 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_NONE));
290 data.SetWant(want);
291 chargerState->HandleChangerStatusCompleted(data);
292 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
293 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_BUTT));
294 data.SetWant(want);
295 chargerState->HandleChangerStatusCompleted(data);
296 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CHARGE_STATE,
297 static_cast<int32_t>(BatteryChargeState::CHARGE_STATE_BUTT));
298 data.SetWant(want);
299 chargerState->HandleChangerStatusCompleted(data);
300 #endif
301 THERMAL_HILOGD(LABEL_TEST, "ThermalObserverTest010 end");
302 }
303 } // namespace
304