1 /*
2 * Copyright (c) 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_config_sensor_cluster_test.h"
17
18 #ifdef THERMAL_GTEST
19 #define private public
20 #define protected public
21 #define final
22 #endif
23
24 #include <map>
25 #include <string>
26 #include <vector>
27
28 #include "config_policy_utils.h"
29 #include "power_mgr_client.h"
30 #include "thermal_config_sensor_cluster.h"
31 #include "thermal_log.h"
32 #include "thermal_service.h"
33
34 using namespace OHOS::PowerMgr;
35 using namespace OHOS;
36 using namespace testing::ext;
37 using namespace std;
38
39 namespace {
40 sptr<ThermalService> g_service = nullptr;
41 } // namespace
42
GetOneCfgFile(const char * pathSuffix,char * buf,unsigned int bufLength)43 char* GetOneCfgFile(const char *pathSuffix, char *buf, unsigned int bufLength)
44 {
45 THERMAL_HILOGI(LABEL_TEST, "mock GetOneCfgFile.");
46 return nullptr;
47 }
48
SetUpTestCase()49 void ThermalConfigSensorClusterTest::SetUpTestCase()
50 {
51 g_service = ThermalService::GetInstance();
52 g_service->InitSystemTestModules();
53 g_service->OnStart();
54 }
55
56 namespace {
57 /**
58 * @tc.name: ThermalConfigSensorClusterTest001
59 * @tc.desc: test CheckStandard
60 * @tc.type: FUNC
61 */
62 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest001, TestSize.Level0)
63 {
64 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest001 function start!");
65
66 ThermalConfigSensorCluster cluster;
67 cluster.sensorInfolist_.clear();
68 EXPECT_FALSE(cluster.CheckStandard());
69
70 // The first for loop returns the value false
71 LevelItem item;
72 item.level = 2;
73 std::vector<LevelItem> vecLevel;
74 vecLevel.push_back(item);
75 cluster.sensorInfolist_["test"] = vecLevel;
76 EXPECT_FALSE(cluster.CheckStandard());
77
78 // continue
79 vecLevel.clear();
80 item.level = 1;
81 vecLevel.push_back(item);
82 cluster.sensorInfolist_["test"] = vecLevel;
83 std::vector<AuxLevelItem> auxLevel;
84 cluster.auxSensorInfolist_["test"] = auxLevel;
85 EXPECT_TRUE(cluster.CheckStandard());
86
87 // The second for loop returns the value false
88 AuxLevelItem auxItem;
89 auxLevel.push_back(auxItem);
90 auxLevel.push_back(auxItem);
91 cluster.auxSensorInfolist_["test"] = auxLevel;
92 EXPECT_FALSE(cluster.CheckStandard());
93
94 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest001 function end!");
95 }
96
97 /**
98 * @tc.name: ThermalConfigSensorClusterTest002
99 * @tc.desc: test UpdateThermalLevel
100 * @tc.type: FUNC
101 */
102 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest002, TestSize.Level0)
103 {
104 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest002 function start!");
105
106 // Null data return
107 ThermalConfigSensorCluster cluster;
108 TypeTempMap typeTempInfo;
109 cluster.UpdateThermalLevel(typeTempInfo);
110 EXPECT_NE(cluster.latestLevel_, 1);
111
112 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest002 function end!");
113 }
114
115 /**
116 * @tc.name: ThermalConfigSensorClusterTest003
117 * @tc.desc: test AscJudgment if branch
118 * @tc.type: FUNC
119 */
120 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest003, TestSize.Level0)
121 {
122 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest003 function start!");
123 // inner if branch (curTemp >= threshold)
124 LevelItem item1;
125 item1.threshold = 0;
126 LevelItem item2;
127 item2.threshold = 0;
128 item2.level = 999;
129 std::vector<LevelItem> levItems1;
130 levItems1.push_back(item1);
131 levItems1.push_back(item2);
132 int32_t curTemp = 1;
133 uint32_t level = 1;
134 TypeTempMap type;
135 ThermalConfigSensorCluster cluster;
136 std::string sensorType = "test";
137 cluster.AscJudgment(levItems1, curTemp, level, type, sensorType);
138 EXPECT_EQ(level, item2.level);
139
140 const int32_t INDEX0 = 0;
141 const int32_t INDEX1 = 1;
142 // The break branch in the for loop
143 levItems1.at(INDEX1).threshold = 3;
144 level = 1;
145 cluster.AscJudgment(levItems1, curTemp, level, type, sensorType);
146 EXPECT_NE(level, item2.level);
147
148 // inner else if branch (curTemp < thresholdClr)
149 levItems1.at(INDEX0).thresholdClr = 2;
150 levItems1.at(INDEX0).level = 999;
151 levItems1.at(INDEX1).threshold = 2;
152 levItems1.at(INDEX1).thresholdClr = 2;
153 level = 1;
154 cluster.AscJudgment(levItems1, curTemp, level, type, sensorType);
155 EXPECT_EQ(level, levItems1.at(INDEX0).level - 1);
156 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest003 function end!");
157 }
158
159 /**
160 * @tc.name: ThermalConfigSensorClusterTest004
161 * @tc.desc: test AscJudgment else if branch
162 * @tc.type: FUNC
163 */
164 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest004, TestSize.Level0)
165 {
166 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest004 function start!");
167
168 LevelItem item;
169 item.thresholdClr = 2;
170 item.level = 999;
171 std::vector<LevelItem> levItems;
172 levItems.push_back(item);
173 int32_t curTemp = 1;
174 uint32_t level = 1;
175 TypeTempMap type;
176 ThermalConfigSensorCluster cluster;
177 std::string sensorType = "test";
178 cluster.AscJudgment(levItems, curTemp, level, type, sensorType);
179 EXPECT_EQ(level, item.level - 1);
180
181 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest004 function end!");
182 }
183
184 /**
185 * @tc.name: ThermalConfigSensorClusterTest005
186 * @tc.desc: test AscJudgment else branch
187 * @tc.type: FUNC
188 */
189 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest005, TestSize.Level0)
190 {
191 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest005 function start!");
192
193 LevelItem item;
194 item.threshold = 1;
195 item.level = 999;
196 std::vector<LevelItem> levItems;
197 levItems.push_back(item);
198 levItems.push_back(item);
199 int32_t curTemp = 1;
200 uint32_t level = 0;
201 TypeTempMap type;
202 ThermalConfigSensorCluster cluster;
203 std::string sensorType = "test";
204 cluster.AscJudgment(levItems, curTemp, level, type, sensorType);
205 EXPECT_EQ(level, item.level);
206
207 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest005 function end!");
208 }
209
210 /**
211 * @tc.name: ThermalConThermalConfigSensorClusterTest006
212 * @tc.desc: test DescJudgment if branch
213 * @tc.type: FUNC
214 */
215 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest006, TestSize.Level0)
216 {
217 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest006 function start!");
218 // inner if branch (curTemp <= nextUptemp)
219 LevelItem item1;
220 item1.threshold = 1;
221 LevelItem item2;
222 item2.threshold = 1;
223 item2.level = 999;
224 std::vector<LevelItem> levItems;
225 levItems.push_back(item1);
226 levItems.push_back(item2);
227 int32_t curTemp = 1;
228 uint32_t level = 1;
229 TypeTempMap type;
230 ThermalConfigSensorCluster cluster;
231 std::string sensorType = "test";
232 cluster.DescJudgment(levItems, curTemp, level, type, sensorType);
233 EXPECT_EQ(level, item2.level);
234
235 const int32_t INDEX0 = 0;
236 const int32_t INDEX1 = 1;
237 // inner else if branch (curTemp > curDownTemp)
238 levItems.at(INDEX0).thresholdClr = 0;
239 levItems.at(INDEX0).level = 999;
240 levItems.at(INDEX1).threshold = 0;
241 levItems.at(INDEX1).thresholdClr = 0;
242 level = 1;
243 cluster.DescJudgment(levItems, curTemp, level, type, sensorType);
244 EXPECT_EQ(level, levItems.at(INDEX0).level - 1);
245 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest006 function end!");
246 }
247
248 /**
249 * @tc.name: ThermalConfigSensorClusterTest007
250 * @tc.desc: test DescJudgment else if branch
251 * @tc.type: FUNC
252 */
253 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest007, TestSize.Level0)
254 {
255 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest007 function start!");
256
257 LevelItem item;
258 item.thresholdClr = 2;
259 item.level = 999;
260 std::vector<LevelItem> levItems;
261 levItems.push_back(item);
262 int32_t curTemp = 3;
263 uint32_t level = 1;
264 TypeTempMap type;
265 ThermalConfigSensorCluster cluster;
266 std::string sensorType = "test";
267 cluster.DescJudgment(levItems, curTemp, level, type, sensorType);
268 EXPECT_EQ(level, item.level - 1);
269
270 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest007 function end!");
271 }
272
273 /**
274 * @tc.name: ThermalConfigSensorClusterTest008
275 * @tc.desc: test DescJudgment else branch
276 * @tc.type: FUNC
277 */
278 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest008, TestSize.Level0)
279 {
280 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest008 function start!");
281
282 LevelItem item;
283 item.threshold = 2;
284 item.level = 999;
285 std::vector<LevelItem> levItems;
286 levItems.push_back(item);
287 levItems.push_back(item);
288 int32_t curTemp = 2;
289 uint32_t level = 0;
290 TypeTempMap type;
291 ThermalConfigSensorCluster cluster;
292 std::string sensorType = "test";
293 cluster.DescJudgment(levItems, curTemp, level, type, sensorType);
294 EXPECT_EQ(level, item.level);
295
296 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest008 function end!");
297 }
298
299 /**
300 * @tc.name: ThermalConfigSensorClusterTest009
301 * @tc.desc: test IsAuxSensorTrigger
302 * @tc.type: FUNC
303 */
304 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest009, TestSize.Level0)
305 {
306 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest009 function start!");
307
308 TypeTempMap typeTempInfo;
309 uint32_t level = 0;
310 ThermalConfigSensorCluster cluster;
311 // Returns true when level = 0
312 EXPECT_TRUE(cluster.IsAuxSensorTrigger(typeTempInfo, level));
313
314 // No matching item is found
315 std::vector<AuxLevelItem> auxLevel;
316 cluster.auxSensorInfolist_["test1"] = auxLevel;
317 level = 1;
318 EXPECT_FALSE(cluster.IsAuxSensorTrigger(typeTempInfo, level));
319
320 AuxLevelItem item;
321 item.lowerTemp = 1;
322 item.upperTemp = 1;
323 auxLevel.push_back(item);
324 cluster.auxSensorInfolist_["test1"] = auxLevel;
325 cluster.auxSensorInfolist_["test"] = auxLevel;
326 cluster.auxSensorInfolist_["test2"] = auxLevel;
327 typeTempInfo["test"] = 1; // The range is lowerTemp and upperTemp
328 typeTempInfo["test2"] = 5; // The range is not lowerTemp or upperTemp
329 level = 1;
330 EXPECT_FALSE(cluster.IsAuxSensorTrigger(typeTempInfo, level));
331
332 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest009 function end!");
333 }
334
335 /**
336 * @tc.name: ThermalConfigSensorClusterTest010
337 * @tc.desc: test IsTempRateTrigger rateMap and sensorInfolist_ No match
338 * @tc.type: FUNC
339 */
340 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest010, TestSize.Level0)
341 {
342 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest010 function start!");
343 g_service->RegisterThermalHdiCallback();
344 ThermalConfigSensorCluster cluster;
345 std::vector<LevelItem> vecLevel;
346 uint32_t level = 0;
347 std::string sensorType = "test";
348 bool isCritical = true;
349 EXPECT_TRUE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
350
351 // false is returned if rate list not full
352 level = 2;
353 auto& rateMap = g_service->serviceSubscriber_->sensorsRateMap_;
354 rateMap["test"].push_back(3.14);
355 LevelItem item1;
356 item1.level = 1;
357 LevelItem item2;
358 item2.level = 2;
359 item2.tempRiseRate = 2.14;
360 vecLevel.push_back(item1);
361 vecLevel.push_back(item2);
362 EXPECT_FALSE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
363
364 // rate list is full
365 rateMap["test"].push_back(3.04);
366 rateMap["test"].push_back(2.94);
367 EXPECT_TRUE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
368
369 // false is returned if not all critical
370 rateMap["test"].clear();
371 rateMap["test"].push_back(3.14);
372 rateMap["test"].push_back(2.14);
373 rateMap["test"].push_back(1.14);
374 EXPECT_FALSE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
375
376 // false is returned if the type is not found
377 sensorType = "test2";
378 EXPECT_FALSE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
379
380 // not critical
381 sensorType = "test";
382 isCritical = false;
383 rateMap["test"].clear();
384 rateMap["test"].push_back(1.14);
385 rateMap["test"].push_back(1.04);
386 rateMap["test"].push_back(0.94);
387 EXPECT_TRUE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
388 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest010 function end!");
389 }
390
391 /**
392 * @tc.name: ThermalConfigSensorClusterTest011
393 * @tc.desc: test IsTempDiffTrigger
394 * @tc.type: FUNC
395 */
396 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest011, TestSize.Level0)
397 {
398 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest011 function start!");
399
400 TypeTempMap typeTempInfo;
401
402 uint32_t level = 0;
403 ThermalConfigSensorCluster cluster;
404 EXPECT_TRUE(cluster.IsTempDiffTrigger(typeTempInfo, level));
405
406 // illegal level parameter
407 level = INT_MAX;
408 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
409 level = -1;
410 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
411
412 TempDiffInfoList tempDiffInfoList;
413 TempDiffItem tdItem1, tdItem2;
414
415 tdItem1.sensor1 = "test1";
416 tdItem1.sensor2 = "test2";
417 tdItem1.tempDiff = 5000;
418 tdItem1.level = 1;
419
420 tdItem2.sensor1 = "test1";
421 tdItem2.sensor2 = "test2";
422 tdItem2.tempDiff = 900000;
423 tdItem2.level = 2;
424
425 tempDiffInfoList.push_back(tdItem2);
426 tempDiffInfoList.push_back(tdItem1);
427 cluster.SetTempDiffInfo(tempDiffInfoList);
428 cluster.SetTempDiffFlag(true);
429
430 // no sensor test2 info
431 level = 1;
432 typeTempInfo["test1"] = 41000;
433 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
434 EXPECT_EQ(level, 1);
435
436 // greater than level 1 diff temperature 5000
437 level = 1;
438 typeTempInfo["test2"] = 35000;
439 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
440 EXPECT_EQ(level, 1);
441
442 // less than or equal to level 1 diff temperature 5000
443 level = 1;
444 typeTempInfo["test2"] = 36000;
445 EXPECT_TRUE(cluster.IsTempDiffTrigger(typeTempInfo, level));
446 EXPECT_EQ(level, 1);
447
448 level = 2;
449 EXPECT_TRUE(cluster.IsTempDiffTrigger(typeTempInfo, level));
450 EXPECT_EQ(level, 2);
451 std::string sensorType = "test";
452 bool isCritical = true;
453 std::vector<LevelItem> vecLevel;
454 cluster.CheckExtraCondition(typeTempInfo, level, sensorType, vecLevel, isCritical);
455
456 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest011 function end!");
457 }
458 } // namespace