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_mgr_interface_test.h"
17 
18 #include <atomic>
19 #include <condition_variable>
20 #include <mutex>
21 
22 #include "constants.h"
23 #include "mock_thermal_mgr_client.h"
24 #include "thermal_log.h"
25 #include "thermal_mgr_client.h"
26 
27 #define private   public
28 #define protected public
29 #include "thermal_service.h"
30 #include "thermal_srv_config_parser.h"
31 #include "v1_1/ithermal_interface.h"
32 #include "v1_1/thermal_types.h"
33 #undef private
34 #undef protected
35 
36 using namespace testing::ext;
37 using namespace OHOS::PowerMgr;
38 using namespace OHOS;
39 using namespace std;
40 using namespace OHOS::HDI::Thermal::V1_1;
41 
42 namespace {
43 std::vector<std::string> typelist;
44 std::condition_variable g_callbackCV;
45 std::mutex g_mutex;
46 constexpr int64_t TIME_OUT = 3;
47 std::atomic_bool g_callbackTriggered = false;
48 std::atomic_bool g_levelCallBack4 = false;
49 std::atomic_bool g_levelCallBack5 = false;
50 const std::string SYSTEM_THERMAL_SERVICE_CONFIG_PATH = "/system/etc/thermal_config/thermal_service_config.xml";
51 sptr<ThermalService> g_service = nullptr;
52 auto& g_thermalMgrClient = ThermalMgrClient::GetInstance();
53 
Notify()54 void Notify()
55 {
56     g_callbackTriggered = true;
57     g_callbackCV.notify_one();
58 }
59 
Wait()60 void Wait()
61 {
62     std::unique_lock<std::mutex> lock(g_mutex);
63     g_callbackCV.wait_for(lock, std::chrono::seconds(TIME_OUT), [] {
64         return g_callbackTriggered.load();
65     });
66     EXPECT_TRUE(g_callbackTriggered);
67     g_callbackTriggered = false;
68 }
69 } // namespace
70 
TearDown()71 void ThermalMgrInterfaceTest::TearDown()
72 {
73     g_service->SetScene("");
74     HdfThermalCallbackInfo event;
75     ThermalZoneInfo info1;
76     info1.type = "battery";
77     info1.temp = 0;
78     event.info.push_back(info1);
79     info1.type = "ap";
80     event.info.push_back(info1);
81     info1.type = "pa";
82     event.info.push_back(info1);
83     info1.type = "shell";
84     event.info.push_back(info1);
85     info1.type = "ambient";
86     event.info.push_back(info1);
87     g_service->HandleThermalCallbackEvent(event);
88     g_callbackTriggered = false;
89 }
90 
SetUpTestCase()91 void ThermalMgrInterfaceTest::SetUpTestCase()
92 {
93     g_service = ThermalService::GetInstance();
94     g_service->InitSystemTestModules();
95     g_service->OnStart();
96     g_service->GetBaseinfoObj()->Init();
97     g_service->GetObserver()->InitSensorTypeMap();
98 }
99 
TearDownTestCase()100 void ThermalMgrInterfaceTest::TearDownTestCase()
101 {
102     g_service->OnStop();
103 }
104 
InitData()105 void ThermalMgrInterfaceTest::InitData()
106 {
107     typelist.push_back(BATTERY);
108     typelist.push_back(SOC);
109 }
110 
OnThermalTempChanged(TempCallbackMap & tempCbMap)111 bool ThermalMgrInterfaceTest::ThermalTempTest1Callback::OnThermalTempChanged(TempCallbackMap& tempCbMap)
112 {
113     int assertValue = 0;
114     for (auto iter : tempCbMap) {
115         THERMAL_HILOGD(LABEL_TEST, "type: %{public}s, temp: %{public}d", iter.first.c_str(), iter.second);
116         EXPECT_EQ(true, iter.second >= assertValue) << "Test Failed";
117     }
118     Notify();
119     return true;
120 }
121 
OnThermalTempChanged(TempCallbackMap & tempCbMap)122 bool ThermalMgrInterfaceTest::ThermalTempTest2Callback::OnThermalTempChanged(TempCallbackMap& tempCbMap)
123 {
124     int assertValue = 0;
125     for (auto iter : tempCbMap) {
126         THERMAL_HILOGD(LABEL_TEST, "type: %{public}s, temp: %{public}d", iter.first.c_str(), iter.second);
127         EXPECT_EQ(true, iter.second >= assertValue) << "Test Failed";
128     }
129     Notify();
130     return true;
131 }
132 
OnThermalLevelChanged(ThermalLevel level)133 bool ThermalMgrInterfaceTest::ThermalLevelTest1Callback::OnThermalLevelChanged(ThermalLevel level)
134 {
135     int assertMin = -1;
136     int assertMax = 7;
137     int32_t levelValue = static_cast<int32_t>(level);
138     THERMAL_HILOGD(LABEL_TEST, "level: %{public}d", levelValue);
139     EXPECT_EQ(true, levelValue >= assertMin && levelValue <= assertMax) << "Test Failed";
140     Notify();
141     return true;
142 }
143 
OnThermalLevelChanged(ThermalLevel level)144 bool ThermalMgrInterfaceTest::ThermalLevelTest2Callback::OnThermalLevelChanged(ThermalLevel level)
145 {
146     int assertMin = -1;
147     int assertMax = 7;
148     int32_t levelValue = static_cast<int32_t>(level);
149     THERMAL_HILOGD(LABEL_TEST, "level: %{public}d", levelValue);
150     EXPECT_EQ(true, levelValue >= assertMin && levelValue <= assertMax) << "Test Failed";
151     Notify();
152     return true;
153 }
154 
OnThermalLevelChanged(ThermalLevel level)155 bool ThermalMgrInterfaceTest::ThermalLevelTest3Callback::OnThermalLevelChanged(ThermalLevel level)
156 {
157     int assertMin = -1;
158     int assertMax = 7;
159     int32_t levelValue = static_cast<int32_t>(level);
160     THERMAL_HILOGD(LABEL_TEST, "level: %{public}d", levelValue);
161     EXPECT_EQ(true, levelValue >= assertMin && levelValue <= assertMax) << "Test Failed";
162     Notify();
163     return true;
164 }
165 
OnThermalLevelChanged(ThermalLevel level)166 bool ThermalMgrInterfaceTest::ThermalLevelTest4Callback::OnThermalLevelChanged(ThermalLevel level)
167 {
168     int assertMin = -1;
169     int assertMax = 7;
170     int32_t levelValue = static_cast<int32_t>(level);
171     THERMAL_HILOGD(LABEL_TEST, "level: %{public}d", levelValue);
172     EXPECT_EQ(true, levelValue >= assertMin && levelValue <= assertMax) << "Test Failed";
173     g_levelCallBack4 = true;
174     g_callbackCV.notify_one();
175     return true;
176 }
177 
OnThermalLevelChanged(ThermalLevel level)178 bool ThermalMgrInterfaceTest::ThermalLevelTest5Callback::OnThermalLevelChanged(ThermalLevel level)
179 {
180     int assertMin = -1;
181     int assertMax = 7;
182     int32_t levelValue = static_cast<int32_t>(level);
183     THERMAL_HILOGD(LABEL_TEST, "level: %{public}d", levelValue);
184     EXPECT_EQ(true, levelValue >= assertMin && levelValue <= assertMax) << "Test Failed";
185     g_levelCallBack5 = true;
186     g_callbackCV.notify_one();
187     return true;
188 }
189 
190 namespace {
191 /**
192  * @tc.name: ThermalMgrInterfaceTest001
193  * @tc.desc: test get sensor temp
194  * @tc.type: FUNC
195  */
196 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest001, TestSize.Level0)
197 {
198     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest001 start");
199     sleep(1);
200     HdfThermalCallbackInfo event;
201     ThermalZoneInfo info1;
202     info1.type = "battery";
203     info1.temp = 41000;
204     event.info.push_back(info1);
205     g_service->HandleThermalCallbackEvent(event);
206     ThermalSrvSensorInfo info;
207     g_service->GetThermalSrvSensorInfo(SensorType::BATTERY, info);
208     g_thermalMgrClient.GetThermalSensorTemp(SensorType::BATTERY);
209     EXPECT_EQ(info1.temp, info.GetTemp()) << "ThermalMgrInterfaceTest001 Failed";
210     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest001 end");
211 }
212 
213 /**
214  * @tc.name: ThermalMgrInterfaceTest002
215  * @tc.desc: test get sensor temp
216  * @tc.type: FUNC
217  */
218 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest002, TestSize.Level0)
219 {
220     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest002 start");
221     HdfThermalCallbackInfo event;
222     ThermalZoneInfo info1;
223     info1.type = "soc";
224     info1.temp = 10000;
225     event.info.push_back(info1);
226     g_service->HandleThermalCallbackEvent(event);
227     ThermalSrvSensorInfo info;
228     g_service->GetThermalSrvSensorInfo(SensorType::SOC, info);
229     g_thermalMgrClient.GetThermalSensorTemp(SensorType::SOC);
230     EXPECT_EQ(info1.temp, info.GetTemp()) << "ThermalMgrInterfaceTest002 Failed";
231     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest002 end");
232 }
233 
234 /**
235  * @tc.name: ThermalMgrInterfaceTest003
236  * @tc.desc: test get sensor temp
237  * @tc.type: FUNC
238  */
239 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest003, TestSize.Level0)
240 {
241     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest003 start");
242     HdfThermalCallbackInfo event;
243     ThermalZoneInfo info1;
244     info1.type = "shell";
245     info1.temp = 11000;
246     event.info.push_back(info1);
247     g_service->HandleThermalCallbackEvent(event);
248     ThermalSrvSensorInfo info;
249     g_service->GetThermalSrvSensorInfo(SensorType::SHELL, info);
250     g_thermalMgrClient.GetThermalSensorTemp(SensorType::SHELL);
251     EXPECT_EQ(info1.temp, info.GetTemp()) << "ThermalMgrInterfaceTest003 Failed";
252     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest003 end");
253 }
254 
255 /**
256  * @tc.name: ThermalMgrInterfaceTest004
257  * @tc.desc: test get sensor temp
258  * @tc.type: FUNC
259  */
260 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest004, TestSize.Level0)
261 {
262     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest004 start");
263     HdfThermalCallbackInfo event;
264     ThermalZoneInfo info1;
265     info1.type = "cpu";
266     info1.temp = 12000;
267     event.info.push_back(info1);
268     g_service->HandleThermalCallbackEvent(event);
269     ThermalSrvSensorInfo info;
270     g_service->GetThermalSrvSensorInfo(SensorType::SENSOR1, info);
271     g_thermalMgrClient.GetThermalSensorTemp(SensorType::SENSOR1);
272     EXPECT_EQ(info1.temp, info.GetTemp()) << "ThermalMgrInterfaceTest004 Failed";
273     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest004 end");
274 }
275 
276 /**
277  * @tc.name: ThermalMgrInterfaceTest005
278  * @tc.desc: test get sensor temp
279  * @tc.type: FUNC
280  */
281 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest005, TestSize.Level0)
282 {
283     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest005 start");
284     HdfThermalCallbackInfo event;
285     ThermalZoneInfo info1;
286     info1.type = "charger";
287     info1.temp = 13000;
288     event.info.push_back(info1);
289     g_service->HandleThermalCallbackEvent(event);
290     ThermalSrvSensorInfo info;
291     g_service->GetThermalSrvSensorInfo(SensorType::SENSOR2, info);
292     g_thermalMgrClient.GetThermalSensorTemp(SensorType::SENSOR2);
293     EXPECT_EQ(info1.temp, info.GetTemp()) << "ThermalMgrInterfaceTest005 Failed";
294     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest005 end");
295 }
296 
297 /**
298  * @tc.name: ThermalMgrInterfaceTest006
299  * @tc.desc: register callback and get temp list
300  * @tc.type: FUNC
301  */
302 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest006, TestSize.Level0)
303 {
304     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest006 start");
305     InitData();
306     const sptr<IThermalTempCallback> cb1 = new ThermalTempTest1Callback();
307     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest006 start register");
308     g_service->SubscribeThermalTempCallback(typelist, cb1);
309     g_thermalMgrClient.SubscribeThermalTempCallback(typelist, cb1);
310     int32_t temp = 10000;
311     for (int i = 0; i < 10; i++) {
312         HdfThermalCallbackInfo event;
313         ThermalZoneInfo info1;
314         info1.type = "soc";
315         info1.temp = temp;
316         event.info.push_back(info1);
317 
318         ThermalZoneInfo info2;
319         info2.type = "battery";
320         info2.temp = temp;
321         event.info.push_back(info2);
322         g_service->HandleThermalCallbackEvent(event);
323         Wait();
324     }
325     g_service->UnSubscribeThermalTempCallback(cb1);
326     g_thermalMgrClient.UnSubscribeThermalTempCallback(cb1);
327     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest006 end");
328 }
329 
330 /**
331  * @tc.name: ThermalMgrInterfaceTest007
332  * @tc.desc: test register callback and get thermal level
333  * @tc.type: FUNC
334  */
335 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest007, TestSize.Level0)
336 {
337     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest007 start");
338     const sptr<IThermalLevelCallback> cb4 = new ThermalLevelTest4Callback();
339     const sptr<IThermalLevelCallback> cb5 = new ThermalLevelTest5Callback();
340     g_thermalMgrClient.SubscribeThermalLevelCallback(cb4);
341     g_service->SubscribeThermalLevelCallback(cb4);
342     g_thermalMgrClient.SubscribeThermalLevelCallback(cb5);
343     g_service->SubscribeThermalLevelCallback(cb5);
344     // thermal Level callback will be triggered when subscribed
345     std::unique_lock<std::mutex> lock(g_mutex);
__anonb915a3ef0402null346     g_callbackCV.wait_for(lock, std::chrono::seconds(TIME_OUT), [] {
347         return (g_levelCallBack4.load() && g_levelCallBack5.load());
348     });
349     EXPECT_TRUE(g_levelCallBack4);
350     EXPECT_TRUE(g_levelCallBack5);
351     g_levelCallBack4 = false;
352     g_levelCallBack5 = false;
353 
354     HdfThermalCallbackInfo event;
355     ThermalZoneInfo info1;
356     info1.type = "battery";
357     info1.temp = -20000;
358     event.info.push_back(info1);
359     g_service->HandleThermalCallbackEvent(event);
360     EXPECT_FALSE(g_levelCallBack4);
361     EXPECT_FALSE(g_levelCallBack5);
362 
363     g_thermalMgrClient.UnSubscribeThermalLevelCallback(cb5);
364     g_service->UnSubscribeThermalLevelCallback(cb5);
365     g_thermalMgrClient.UnSubscribeThermalLevelCallback(cb4);
366     g_service->UnSubscribeThermalLevelCallback(cb4);
367     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest007 end");
368 }
369 
370 /**
371  * @tc.name: ThermalMgrInterfaceTest008
372  * @tc.desc: test register callback and get thermal level
373  * @tc.type: FUNC
374  */
375 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest008, TestSize.Level0)
376 {
377     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest008 start");
378     const sptr<IThermalLevelCallback> cb2 = new ThermalLevelTest2Callback();
379     g_thermalMgrClient.SubscribeThermalLevelCallback(cb2);
380     g_service->SubscribeThermalLevelCallback(cb2);
381     Wait(); // thermal Level callback will be triggered when subscribed
382 
383     int32_t temp = -25100;
384     for (uint32_t i = 0; i < 5; i++) {
385         THERMAL_HILOGD(LABEL_TEST, "temp: %{public}d", temp);
386         HdfThermalCallbackInfo event;
387         ThermalZoneInfo info1;
388         info1.type = "battery";
389         info1.temp = temp;
390         event.info.push_back(info1);
391         g_service->HandleThermalCallbackEvent(event);
392         temp += 5000;
393         EXPECT_FALSE(g_callbackTriggered);
394     }
395     temp = 40100;
396     for (uint32_t i = 0; i < 3; i++) {
397         HdfThermalCallbackInfo event;
398         ThermalZoneInfo info1;
399         info1.type = "battery";
400         info1.temp = temp;
401         event.info.push_back(info1);
402         g_service->HandleThermalCallbackEvent(event);
403         temp += 3000;
404         Wait();
405     }
406     g_thermalMgrClient.UnSubscribeThermalLevelCallback(cb2);
407     g_service->SubscribeThermalLevelCallback(cb2);
408     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest008 end");
409 }
410 
411 /**
412  * @tc.name: ThermalMgrInterfaceTest009
413  * @tc.desc: test register callback and get thermal level
414  * @tc.type: FUNC
415  */
416 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest009, TestSize.Level0)
417 {
418     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest009 start");
419     const sptr<IThermalLevelCallback> cb1 = new ThermalLevelTest1Callback();
420     g_thermalMgrClient.SubscribeThermalLevelCallback(cb1);
421     g_service->SubscribeThermalLevelCallback(cb1);
422     Wait(); // thermal Level callback will be triggered when subscribed
423 
424     HdfThermalCallbackInfo event;
425     ThermalZoneInfo info1;
426     info1.type = "battery";
427     info1.temp = -20000;
428     event.info.push_back(info1);
429     g_service->HandleThermalCallbackEvent(event);
430     EXPECT_FALSE(g_callbackTriggered);
431     event.info.clear();
432 
433     info1.temp = 40100;
434     event.info.push_back(info1);
435     g_service->HandleThermalCallbackEvent(event);
436     Wait();
437     event.info.clear();
438 
439     info1.temp = -10000;
440     event.info.push_back(info1);
441     g_service->HandleThermalCallbackEvent(event);
442     Wait();
443     event.info.clear();
444 
445     info1.temp = 46000;
446     event.info.push_back(info1);
447     g_service->HandleThermalCallbackEvent(event);
448     Wait();
449 
450     g_thermalMgrClient.UnSubscribeThermalLevelCallback(cb1);
451     g_service->UnSubscribeThermalLevelCallback(cb1);
452     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest009 end");
453 }
454 
455 /**
456  * @tc.name: ThermalMgrInterfaceTest010
457  * @tc.desc: test register callback and get thermal level
458  * @tc.type: FUNC
459  */
460 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest010, TestSize.Level0)
461 {
462     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest010 start");
463     const sptr<IThermalLevelCallback> cb1 = new ThermalLevelTest1Callback();
464     g_thermalMgrClient.SubscribeThermalLevelCallback(cb1);
465     g_service->SubscribeThermalLevelCallback(cb1);
466     Wait(); // thermal Level callback will be triggered when subscribed
467 
468     HdfThermalCallbackInfo event;
469     ThermalZoneInfo info1;
470     info1.type = "battery";
471     info1.temp = -20000;
472     event.info.push_back(info1);
473     g_service->HandleThermalCallbackEvent(event);
474     EXPECT_FALSE(g_callbackTriggered);
475     g_thermalMgrClient.UnSubscribeThermalLevelCallback(cb1);
476     g_service->UnSubscribeThermalLevelCallback(cb1);
477 
478     g_service->HandleThermalCallbackEvent(event);
479     g_thermalMgrClient.SubscribeThermalLevelCallback(cb1);
480     g_service->SubscribeThermalLevelCallback(cb1);
481     Wait(); // thermal Level callback will be triggered when subscribed
482 
483     event.info.clear();
484     info1.temp = 48000;
485     event.info.push_back(info1);
486     g_service->HandleThermalCallbackEvent(event);
487     Wait();
488 
489     g_thermalMgrClient.UnSubscribeThermalLevelCallback(cb1);
490     g_service->UnSubscribeThermalLevelCallback(cb1);
491     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest020 end");
492 }
493 
494 /**
495  * @tc.name: ThermalMgrInterfaceTest011
496  * @tc.desc: register callback and get temp list
497  * @tc.type: FUNC
498  */
499 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest011, TestSize.Level0)
500 {
501     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest011 start");
502     InitData();
503     const sptr<IThermalTempCallback> cb1 = new ThermalTempTest1Callback();
504     g_service->SubscribeThermalTempCallback(typelist, cb1);
505     g_thermalMgrClient.SubscribeThermalTempCallback(typelist, cb1);
506     int32_t temp = 10000;
507     for (int i = 0; i < 10; i++) {
508         HdfThermalCallbackInfo event;
509         ThermalZoneInfo info1;
510         info1.type = "soc";
511         info1.temp = temp;
512         event.info.push_back(info1);
513 
514         ThermalZoneInfo info2;
515         info2.type = "battery";
516         info2.temp = temp;
517         event.info.push_back(info2);
518         g_service->HandleThermalCallbackEvent(event);
519         temp += 100;
520         Wait();
521     }
522     g_service->UnSubscribeThermalTempCallback(cb1);
523     g_thermalMgrClient.UnSubscribeThermalTempCallback(cb1);
524     const sptr<IThermalTempCallback> cb2 = new ThermalTempTest2Callback();
525     g_service->SubscribeThermalTempCallback(typelist, cb1);
526     g_thermalMgrClient.SubscribeThermalTempCallback(typelist, cb1);
527     for (int i = 0; i < 10; i++) {
528         HdfThermalCallbackInfo event;
529         ThermalZoneInfo info1;
530         info1.type = "soc";
531         info1.temp = temp;
532         event.info.push_back(info1);
533 
534         ThermalZoneInfo info2;
535         info2.type = "battery";
536         info2.temp = temp;
537         event.info.push_back(info2);
538         g_service->HandleThermalCallbackEvent(event);
539         temp += 100;
540         Wait();
541     }
542     g_service->UnSubscribeThermalTempCallback(cb1);
543     g_thermalMgrClient.UnSubscribeThermalTempCallback(cb1);
544     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest011 end");
545 }
546 
547 /**
548  * @tc.name: ThermalMgrInterfaceTest012
549  * @tc.desc: test get invaild temp
550  * @tc.type: FUNC
551  */
552 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest012, TestSize.Level0)
553 {
554     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest012 start");
555     HdfThermalCallbackInfo event;
556     ThermalZoneInfo info1;
557     info1.type = "battery";
558     info1.temp = INVAILD_TEMP;
559     event.info.push_back(info1);
560     g_service->HandleThermalCallbackEvent(event);
561     g_thermalMgrClient.GetThermalSensorTemp(SensorType::BATTERY);
562     ThermalSrvSensorInfo info;
563     g_service->GetThermalSrvSensorInfo(SensorType::BATTERY, info);
564     EXPECT_EQ(INVAILD_TEMP, info.GetTemp()) << "ThermalMgrInterfaceTest012 Failed";
565     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest012 end");
566 }
567 
568 /**
569  * @tc.name: ThermalMgrInterfaceTest013
570  * @tc.desc: test get invaild temp
571  * @tc.type: FUNC
572  */
573 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest013, TestSize.Level0)
574 {
575     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest013 start");
576     const sptr<IThermalTempCallback> cb = nullptr;
577     InitData();
578     g_thermalMgrClient.SubscribeThermalTempCallback(typelist, cb);
579     g_service->SubscribeThermalTempCallback(typelist, cb);
580     HdfThermalCallbackInfo event;
581     ThermalZoneInfo info1;
582     info1.type = "battery";
583     info1.temp = INVAILD_TEMP;
584     event.info.push_back(info1);
585     g_service->HandleThermalCallbackEvent(event);
586     g_thermalMgrClient.UnSubscribeThermalTempCallback(cb);
587     EXPECT_TRUE(g_service->UnSubscribeThermalTempCallback(cb));
588     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest013 end");
589 }
590 
591 /**
592  * @tc.name: ThermalMgrInterfaceTest014
593  * @tc.desc: test register null callback
594  * @tc.type: FUNC
595  */
596 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest014, TestSize.Level0)
597 {
598     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest014 start");
599     const sptr<IThermalLevelCallback> cb = nullptr;
600     g_thermalMgrClient.SubscribeThermalLevelCallback(cb);
601     g_service->SubscribeThermalLevelCallback(cb);
602     HdfThermalCallbackInfo event;
603     ThermalZoneInfo info1;
604     info1.type = "battery";
605     info1.temp = INVAILD_TEMP;
606     event.info.push_back(info1);
607     g_service->HandleThermalCallbackEvent(event);
608     g_thermalMgrClient.UnSubscribeThermalLevelCallback(cb);
609     EXPECT_TRUE(g_service->UnSubscribeThermalLevelCallback(cb));
610     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest014 end");
611 }
612 
613 /**
614  * @tc.name: ThermalMgrInterfaceTest015
615  * @tc.desc: test get level
616  * @tc.type: FUNC
617  */
618 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest015, TestSize.Level0)
619 {
620     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest015 start");
621     std::vector<int32_t> temps {-1000, 40100, 43100, 46100};
622     std::vector<ThermalLevel> levels {ThermalLevel::COOL, ThermalLevel::NORMAL, ThermalLevel::WARM, ThermalLevel::HOT};
623     for (uint32_t i = 0; i < temps.size(); ++i) {
624         HdfThermalCallbackInfo event;
625         ThermalZoneInfo info1;
626         info1.type = "battery";
627         info1.temp = temps[i];
628         event.info.push_back(info1);
629         g_service->HandleThermalCallbackEvent(event);
630         g_thermalMgrClient.GetThermalLevel();
631         ThermalLevel level;
632         g_service->GetThermalLevel(level);
633         GTEST_LOG_(INFO) << "test thermal temp: " << temps[i];
634         EXPECT_EQ(level, levels[i]) << "ThermalMgrInterfaceTest015 Failed";
635     }
636     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest015 end");
637 }
638 
639 /**
640  * @tc.name: ThermalMgrInterfaceTest016
641  * @tc.desc: test get level
642  * @tc.type: FUNC
643  */
644 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest016, TestSize.Level0)
645 {
646     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest016 start");
647     HdfThermalCallbackInfo event;
648     ThermalZoneInfo info1;
649     info1.type = "pa";
650     info1.temp = 40100;
651     event.info.push_back(info1);
652     info1.type = "ambient";
653     info1.temp = 20000;
654     event.info.push_back(info1);
655     g_service->HandleThermalCallbackEvent(event);
656     g_thermalMgrClient.GetThermalLevel();
657     ThermalLevel level;
658     g_service->GetThermalLevel(level);
659     EXPECT_EQ(level, ThermalLevel::OVERHEATED) << "ThermalMgrInterfaceTest016 Failed";
660     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest016 end");
661 }
662 
663 /**
664  * @tc.name: ThermalMgrInterfaceTest017
665  * @tc.desc: test get level
666  * @tc.type: FUNC
667  */
668 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest017, TestSize.Level0)
669 {
670     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest017 start");
671     HdfThermalCallbackInfo event;
672     ThermalZoneInfo info1;
673     info1.type = "pa";
674     info1.temp = 44100;
675     event.info.push_back(info1);
676     info1.type = "ambient";
677     info1.temp = 20000;
678     event.info.push_back(info1);
679     g_service->HandleThermalCallbackEvent(event);
680     g_thermalMgrClient.GetThermalLevel();
681     ThermalLevel level;
682     g_service->GetThermalLevel(level);
683     EXPECT_EQ(level, ThermalLevel::WARNING) << "ThermalMgrInterfaceTest017 Failed";
684     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest017 end");
685 }
686 
687 /**
688  * @tc.name: ThermalMgrInterfaceTest018
689  * @tc.desc: Get Thermal Level
690  * @tc.type: FUNC
691  * @tc.result: level get min
692  */
693 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest018, TestSize.Level0)
694 {
695     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest018 start");
696     HdfThermalCallbackInfo event;
697     ThermalZoneInfo info1;
698     info1.type = "ap";
699     info1.temp = 79000;
700     event.info.push_back(info1);
701     info1.type = "ambient";
702     info1.temp = 60000;
703     event.info.push_back(info1);
704     info1.type = "shell";
705     info1.temp = 30000;
706     event.info.push_back(info1);
707     g_service->HandleThermalCallbackEvent(event);
708     g_thermalMgrClient.GetThermalLevel();
709     ThermalLevel level;
710     g_service->GetThermalLevel(level);
711     EXPECT_EQ(level, ThermalLevel::EMERGENCY) << "ThermalMgrInterfaceTest018 Failed";
712     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest018 end");
713 }
714 
715 /**
716  * @tc.name: ThermalMgrInterfaceTest019
717  * @tc.desc: test get ESCAPE level
718  * @tc.type: FUNC
719  */
720 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest019, TestSize.Level0)
721 {
722     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest019 start");
723     HdfThermalCallbackInfo event;
724     ThermalZoneInfo info1;
725     info1.type = "pa";
726     info1.temp = 46100;
727     event.info.push_back(info1);
728     info1.type = "ambient";
729     info1.temp = 20000;
730     event.info.push_back(info1);
731     g_service->HandleThermalCallbackEvent(event);
732     g_thermalMgrClient.GetThermalLevel();
733     ThermalLevel level;
734     g_service->GetThermalLevel(level);
735     EXPECT_EQ(level, ThermalLevel::ESCAPE) << "ThermalMgrInterfaceTest019 Failed";
736     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest019 end");
737 }
738 
739 /**
740  * @tc.name: ThermalMgrInterfaceTest020
741  * @tc.desc: Update Thermal State
742  * @tc.type: FUNC
743  * @tc.result: state changed
744  */
745 HWTEST_F(ThermalMgrInterfaceTest, ThermalMgrInterfaceTest020, TestSize.Level0)
746 {
747     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest020 start");
748     std::string tag1 = "modeid";
749     std::string val1 = "100";
750     bool ret = g_thermalMgrClient.UpdateThermalState(tag1, val1, false);
751     EXPECT_TRUE(ret == true);
752     g_service->UpdateThermalState(tag1, val1, false);
753     std::map<std::string, std::string> stateMap {{tag1, val1}};
754     bool result = g_service->GetPolicy()->StateMachineDecision(stateMap);
755     EXPECT_TRUE(result == true);
756 
757     HdfThermalCallbackInfo event;
758     ThermalZoneInfo info1;
759     info1.type = "battery";
760     info1.temp = 40100;
761     event.info.push_back(info1);
762     g_service->HandleThermalCallbackEvent(event);
763     int32_t value = ConvertInt(GetNodeValue(CONFIG_LEVEL_PATH));
764     EXPECT_TRUE(value == 1);
765     THERMAL_HILOGD(LABEL_TEST, "ThermalMgrInterfaceTest020 end");
766 }
767 
768 } // namespace
769