1 /*
2 * Copyright (c) 2021-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 "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 using namespace testing::ext;
32 using namespace OHOS::PowerMgr;
33 using namespace OHOS;
34 using namespace std;
35 using namespace OHOS::EventFwk;
36
37 namespace {
38 static sptr<ThermalService> g_service = nullptr;
39 }
40
SetUpTestCase()41 void ThermalObserverTest::SetUpTestCase()
42 {
43 g_service = DelayedSpSingleton<ThermalService>::GetInstance();
44 g_service->OnStart();
45 }
46
TearDownTestCase()47 void ThermalObserverTest::TearDownTestCase()
48 {
49 g_service->OnStop();
50 }
51
SetUp()52 void ThermalObserverTest::SetUp() {}
53
TearDown()54 void ThermalObserverTest::TearDown() {}
55
HandleScreenOnCompleted(const CommonEventData & data)56 void ThermalObserverTest::HandleScreenOnCompleted(const CommonEventData& data __attribute__((__unused__)))
57 {
58 }
59
OnThermalTempChanged(TempCallbackMap & tempCbMap)60 bool ThermalObserverTest::ThermalTempTestCallback::OnThermalTempChanged(TempCallbackMap& tempCbMap)
61 {
62 return true;
63 }
64
OnThermalActionChanged(ActionCallbackMap & actionCbMap)65 bool ThermalObserverTest::ThermalActionTestCallback::OnThermalActionChanged(ActionCallbackMap& actionCbMap)
66 {
67 return true;
68 }
69
70 namespace {
71 /**
72 * @tc.name: ThermalObserverTest001
73 * @tc.desc: Thermal Common Event Receiver Function Test
74 * @tc.type: FUNC
75 */
76 HWTEST_F(ThermalObserverTest, ThermalObserverTest001, TestSize.Level0)
77 {
78 EventHandle handlerOn = std::bind(&ThermalObserverTest::HandleScreenOnCompleted, this, std::placeholders::_1);
79 auto receiver = std::make_shared<ThermalCommonEventReceiver>();
80 bool on = receiver->Start(CommonEventSupport::COMMON_EVENT_SCREEN_ON, handlerOn);
81 EXPECT_TRUE(on);
82 CommonEventData data;
83 receiver->HandleEventChanged(data);
84 }
85
86 /**
87 * @tc.name: ThermalObserverTest002
88 * @tc.desc: Thermal Observer Function Test
89 * @tc.type: FUNC
90 */
91 HWTEST_F(ThermalObserverTest, ThermalObserverTest002, TestSize.Level0)
92 {
93 auto observer = std::make_shared<ThermalObserver>(g_service);
94 std::vector<std::string> typeList;
95 sptr<IThermalTempCallback> tempCallback;
96 observer->Init();
97 observer->SubscribeThermalTempCallback(typeList, tempCallback);
98 sptr<IThermalTempCallback> tempCb = new ThermalTempTestCallback();
99 observer->SubscribeThermalTempCallback(typeList, tempCb);
100 observer->UnSubscribeThermalTempCallback(tempCb);
101 sptr<IThermalActionCallback> actionCb;
102 observer->SubscribeThermalActionCallback(typeList, "desc", actionCb);
103 actionCb = new ThermalActionTestCallback();
104 observer->SubscribeThermalActionCallback(typeList, "desc", actionCb);
105 observer->UnSubscribeThermalActionCallback(actionCb);
106 observer->FindSubscribeActionValue();
107 IThermalActionCallback::ActionCallbackMap actionCbMap;
108 observer->DecisionActionValue(typeList, actionCbMap);
109 typeList.push_back("cpu_big");
110 typeList.push_back("cpu_med");
111 typeList.push_back("cpu_lit");
112 observer->DecisionActionValue(typeList, actionCbMap);
113 IThermalActionCallback::ActionCallbackMap map1;
114 IThermalActionCallback::ActionCallbackMap map2;
115 map1.insert(std::make_pair("lcd", 1.0));
116 map2.insert(std::make_pair("lcd", 1.0));
117 bool ret = observer->CompareActionCallbackMap(map1, map2);
118 EXPECT_TRUE(ret);
119 map1.clear();
120 map2.clear();
121 ret = observer->CompareActionCallbackMap(map1, map2);
122 map1.insert(std::make_pair("lcd", 1.0));
123 map2.insert(std::make_pair("cpu", 2.0));
124 ret = observer->CompareActionCallbackMap(map1, map2);
125 IThermalTempCallback::TempCallbackMap tempCbMap;
126 observer->NotifySensorTempChanged(tempCbMap);
127 TypeTempMap info;
128 observer->OnReceivedSensorInfo(info);
129 SensorType type = SensorType::SOC;
130 ThermalSrvSensorInfo sensorInfo;
131 observer->GetThermalSrvSensorInfo(type, sensorInfo);
132 observer->GetTemp(type);
133 observer->NotifyActionChanged(actionCb, map1);
134 }
135
136 /**
137 * @tc.name: ThermalObserverTest003
138 * @tc.desc: Thermal Observer OnRemoteDied Test
139 * @tc.type: FUNC
140 */
141 HWTEST_F(ThermalObserverTest, ThermalObserverTest003, TestSize.Level0)
142 {
143 std::shared_ptr<IRemoteObject::DeathRecipient> deathRecipient =
144 std::make_shared<ThermalObserver::SensorTempCallbackDeathRecipient>();
145 wptr<IRemoteObject> remoteObj = nullptr;
146 EXPECT_NE(deathRecipient, nullptr);
147 deathRecipient->OnRemoteDied(remoteObj);
148
149 sptr<IRemoteObject> sptrRemoteObj = new MockThermalRemoteObject();
150 EXPECT_FALSE(sptrRemoteObj == nullptr);
151 deathRecipient->OnRemoteDied(sptrRemoteObj);
152 }
153
154 /**
155 * @tc.name: ThermalObserverTest004
156 * @tc.desc: Thermal Observer OnRemoteDied Test
157 * @tc.type: FUNC
158 */
159 HWTEST_F(ThermalObserverTest, ThermalObserverTest004, TestSize.Level0)
160 {
161 std::shared_ptr<IRemoteObject::DeathRecipient> deathRecipient =
162 std::make_shared<ThermalObserver::ActionCallbackDeathRecipient>();
163 wptr<IRemoteObject> remoteObj = nullptr;
164 EXPECT_NE(deathRecipient, nullptr);
165 deathRecipient->OnRemoteDied(remoteObj);
166
167 sptr<IRemoteObject> sptrRemoteObj = new MockThermalRemoteObject();
168 EXPECT_FALSE(sptrRemoteObj == nullptr);
169 deathRecipient->OnRemoteDied(sptrRemoteObj);
170 }
171
172 /**
173 * @tc.name: ThermalObserverTest005
174 * @tc.desc: Thermal Sensor Info Test
175 * @tc.type: FUNC
176 * @tc.require: issueI6KRS8
177 */
178 HWTEST_F(ThermalObserverTest, ThermalObserverTest005, TestSize.Level0)
179 {
180 auto info = std::make_shared<ThermalSensorInfo>();
181 EXPECT_TRUE(info->GetTypeTempMap().empty());
182 TypeTempMap type;
183 info->SetTypeTempMap(type);
184 info->GetTemp("soc");
185 EXPECT_TRUE(info->GetHistoryTemperature("soc").empty());
186 info->NotifyObserver();
187 }
188
189 /**
190 * @tc.name: ThermalObserverTest006
191 * @tc.desc: Thermal Charger State Collection Test
192 * @tc.type: FUNC
193 */
194 HWTEST_F(ThermalObserverTest, ThermalObserverTest006, TestSize.Level0)
195 {
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 }
210
211 /**
212 * @tc.name: ThermalObserverTest007
213 * @tc.desc: Thermal Scene State Collection Test
214 * @tc.type: FUNC
215 */
216 HWTEST_F(ThermalObserverTest, ThermalObserverTest007, TestSize.Level0)
217 {
218 auto sceneState = std::make_shared<SceneStateCollection>();
219 sceneState->Init();
220 string param = "game";
221 bool ret = sceneState->InitParam(param);
222 EXPECT_TRUE(ret);
223 sceneState->SetState();
224 sceneState->DecideState("game");
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 auto screenState = std::make_shared<ScreenStateCollection>();
235 screenState->Init();
236 string param = "on";
237 bool ret = screenState->InitParam(param);
238 EXPECT_TRUE(ret);
239 screenState->GetState();
240 screenState->RegisterEvent();
241 CommonEventData data;
242 screenState->HandleScreenOnCompleted(data);
243 screenState->HandleScreenOffCompleted(data);
244 screenState->SetState();
245 screenState->DecideState("0");
246 }
247
248 /**
249 * @tc.name: ThermalObserverTest009
250 * @tc.desc: Thermal State Machine Test
251 * @tc.type: FUNC
252 */
253 HWTEST_F(ThermalObserverTest, ThermalObserverTest009, TestSize.Level0)
254 {
255 auto stateMachine = std::make_shared<StateMachine>();
256 bool ret = stateMachine->Init();
257 EXPECT_TRUE(ret);
258 }
259 } // namespace
260