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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 EXPECT_EQ(level, 1);
320
321 AuxLevelItem item;
322 item.lowerTemp = 1;
323 item.upperTemp = 1;
324 auxLevel.push_back(item);
325 cluster.auxSensorInfolist_["test1"] = auxLevel;
326 cluster.auxSensorInfolist_["test"] = auxLevel;
327 cluster.auxSensorInfolist_["test2"] = auxLevel;
328 typeTempInfo["test"] = 1; // The range is lowerTemp and upperTemp
329 typeTempInfo["test2"] = 5; // The range is not lowerTemp or upperTemp
330 level = 1;
331 EXPECT_FALSE(cluster.IsAuxSensorTrigger(typeTempInfo, level));
332 EXPECT_EQ(level, 1);
333
334 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest009 end.");
335 }
336
337 /**
338 * @tc.name: ThermalConfigSensorClusterTest010
339 * @tc.desc: test IsTempRateTrigger rateMap and sensorInfolist_ No match
340 * @tc.type: FUNC
341 */
342 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest010, TestSize.Level0)
343 {
344 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest010 start.");
345 g_service->RegisterThermalHdiCallback();
346 ThermalConfigSensorCluster cluster;
347 std::vector<LevelItem> vecLevel;
348 uint32_t level = 0;
349 std::string sensorType = "test";
350 bool isCritical = true;
351 EXPECT_TRUE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
352
353 // false is returned if rate list not full
354 level = 2;
355 auto& rateMap = g_service->serviceSubscriber_->sensorsRateMap_;
356 rateMap["test"].push_back(3.14);
357 LevelItem item1;
358 item1.level = 1;
359 LevelItem item2;
360 item2.level = 2;
361 item2.tempRiseRate = 2.14;
362 vecLevel.push_back(item1);
363 vecLevel.push_back(item2);
364 EXPECT_FALSE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
365
366 // rate list is full
367 rateMap["test"].push_back(3.04);
368 rateMap["test"].push_back(2.94);
369 EXPECT_TRUE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
370
371 // false is returned if not all critical
372 rateMap["test"].clear();
373 rateMap["test"].push_back(3.14);
374 rateMap["test"].push_back(2.14);
375 rateMap["test"].push_back(1.14);
376 EXPECT_FALSE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
377
378 // false is returned if the type is not found
379 sensorType = "test2";
380 EXPECT_FALSE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
381
382 // not critical
383 sensorType = "test";
384 isCritical = false;
385 rateMap["test"].clear();
386 rateMap["test"].push_back(1.14);
387 rateMap["test"].push_back(1.04);
388 rateMap["test"].push_back(0.94);
389 EXPECT_TRUE(cluster.IsTempRateTrigger(level, sensorType, vecLevel, isCritical));
390 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest010 end.");
391 }
392
393 /**
394 * @tc.name: ThermalConfigSensorClusterTest011
395 * @tc.desc: test IsTempDiffTrigger
396 * @tc.type: FUNC
397 */
398 HWTEST_F(ThermalConfigSensorClusterTest, ThermalConfigSensorClusterTest011, TestSize.Level0)
399 {
400 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest011 start.");
401
402 TypeTempMap typeTempInfo;
403
404 uint32_t level = 0;
405 ThermalConfigSensorCluster cluster;
406 EXPECT_TRUE(cluster.IsTempDiffTrigger(typeTempInfo, level));
407
408 // illegal level parameter
409 level = INT_MAX;
410 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
411 level = -1;
412 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
413
414 TempDiffInfoList tempDiffInfoList;
415 TempDiffItem tdItem1, tdItem2;
416
417 tdItem1.sensor1 = "test1";
418 tdItem1.sensor2 = "test2";
419 tdItem1.tempDiff = 5000;
420 tdItem1.level = 1;
421
422 tdItem2.sensor1 = "test1";
423 tdItem2.sensor2 = "test2";
424 tdItem2.tempDiff = 900000;
425 tdItem2.level = 2;
426
427 tempDiffInfoList.push_back(tdItem2);
428 tempDiffInfoList.push_back(tdItem1);
429 cluster.SetTempDiffInfo(tempDiffInfoList);
430 cluster.SetTempDiffFlag(true);
431
432 // no sensor test2 info
433 level = 1;
434 typeTempInfo["test1"] = 41000;
435 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
436 EXPECT_EQ(level, 1);
437
438 // greater than level 1 diff temperature 5000
439 level = 1;
440 typeTempInfo["test2"] = 35000;
441 EXPECT_FALSE(cluster.IsTempDiffTrigger(typeTempInfo, level));
442 EXPECT_EQ(level, 1);
443
444 // less than or equal to level 1 diff temperature 5000
445 level = 1;
446 typeTempInfo["test2"] = 36000;
447 EXPECT_TRUE(cluster.IsTempDiffTrigger(typeTempInfo, level));
448 EXPECT_EQ(level, 1);
449
450 level = 2;
451 EXPECT_TRUE(cluster.IsTempDiffTrigger(typeTempInfo, level));
452 EXPECT_EQ(level, 2);
453 std::string sensorType = "test";
454 bool isCritical = true;
455 std::vector<LevelItem> vecLevel;
456 cluster.CheckExtraCondition(typeTempInfo, level, sensorType, vecLevel, isCritical);
457
458 THERMAL_HILOGI(LABEL_TEST, "ThermalConfigSensorClusterTest011 end.");
459 }
460 } // namespace