1 /*
2  * Copyright (c) 2022-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 "stats_util_test.h"
17 
18 #include "battery_stats_parser.h"
19 #include "stats_helper.h"
20 #include "stats_hisysevent.h"
21 #include "stats_utils.h"
22 
23 using namespace testing::ext;
24 using namespace OHOS::PowerMgr;
25 using namespace std;
26 
SetUpTestCase()27 void StatsUtilTest::SetUpTestCase()
28 {
29 }
30 
TearDownTestCase()31 void StatsUtilTest::TearDownTestCase()
32 {
33 }
34 
SetUp()35 void StatsUtilTest::SetUp()
36 {
37     StatsHelper::SetOnBattery(true);
38 }
39 
TearDown()40 void StatsUtilTest::TearDown()
41 {
42     StatsHelper::SetOnBattery(false);
43 }
44 
45 namespace {
46 /**
47  * @tc.name: StatsHiSysEvent_001
48  * @tc.desc: test StatsHiSysEvent function
49  * @tc.type: FUNC
50  * @tc.require: issueI5X13X
51  */
52 HWTEST_F (StatsUtilTest, StatsHiSysEvent_001, TestSize.Level0)
53 {
54     EXPECT_TRUE(StatsHiSysEvent::CheckHiSysEvent(StatsHiSysEvent::POWER_RUNNINGLOCK));
55     EXPECT_FALSE(StatsHiSysEvent::CheckHiSysEvent("POWER_RUNNINGLOCK_WRONG"));
56 }
57 
58 /**
59  * @tc.name: StatsUtils_001
60  * @tc.desc: test class StatsUtils ConvertStatsType function
61  * @tc.type: FUNC
62  * @tc.require: issueI5X13X
63  */
64 HWTEST_F (StatsUtilTest, StatsUtils_001, TestSize.Level0)
65 {
66     EXPECT_EQ("", StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_INVALID));
67     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BR_ON),
68         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BR_ON));
69     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BR_SCAN),
70         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BR_SCAN));
71     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BLE_ON),
72         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BLE_ON));
73     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BLE_SCAN),
74         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BLE_SCAN));
75     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WIFI_ON),
76         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WIFI_ON));
77     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WIFI_SCAN),
78         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WIFI_SCAN));
79     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_PHONE_ACTIVE),
80         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_PHONE_ACTIVE));
81     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_PHONE_DATA),
82         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_PHONE_DATA));
83     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BATTERY),
84         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BATTERY));
85     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WORKSCHEDULER),
86         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WORKSCHEDULER));
87     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_THERMAL),
88         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_THERMAL));
89     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_DISTRIBUTEDSCHEDULER),
90         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_DISTRIBUTEDSCHEDULER));
91 }
92 
93 /**
94  * @tc.name: StatsUtils_002
95  * @tc.desc: test class StatsUtils ConvertStatsType function
96  * @tc.type: FUNC
97  * @tc.require: issueI5X13X
98  */
99 HWTEST_F (StatsUtilTest, StatsUtils_002, TestSize.Level0)
100 {
101     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CAMERA_ON),
102         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CAMERA_ON));
103     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CAMERA_FLASHLIGHT_ON),
104         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CAMERA_FLASHLIGHT_ON));
105     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_FLASHLIGHT_ON),
106         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_FLASHLIGHT_ON));
107     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_GNSS_ON),
108         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_GNSS_ON));
109     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SENSOR_GRAVITY_ON),
110         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SENSOR_GRAVITY_ON));
111     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SENSOR_PROXIMITY_ON),
112         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SENSOR_PROXIMITY_ON));
113     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_AUDIO_ON),
114         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_AUDIO_ON));
115     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SCREEN_ON),
116         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SCREEN_ON));
117     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SCREEN_BRIGHTNESS),
118         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SCREEN_BRIGHTNESS));
119     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_ALARM),
120         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_ALARM));
121     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WAKELOCK_HOLD),
122         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WAKELOCK_HOLD));
123     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_PHONE_IDLE),
124         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_PHONE_IDLE));
125     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_CLUSTER),
126         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_CLUSTER));
127     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_SPEED),
128         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_SPEED));
129     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_ACTIVE),
130         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_ACTIVE));
131     EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_SUSPEND),
132         StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_SUSPEND));
133 }
134 
135 /**
136  * @tc.name: StatsHelper_001
137  * @tc.desc: test class ActiveTimer function
138  * @tc.type: FUNC
139  * @tc.require: issueI5X13X
140  */
141 HWTEST_F (StatsUtilTest, StatsHelper_001, TestSize.Level0)
142 {
143     int64_t activeTimeMs = StatsUtils::DEFAULT_VALUE;
144     int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
145     std::shared_ptr<StatsHelper::ActiveTimer> timer = std::make_shared<StatsHelper::ActiveTimer>();
146     timer->StartRunning();
147     usleep(TIMER_DURATION_MS * US_PER_MS);
148     timer->StopRunning();
149     activeTimeMs = timer->GetRunningTimeMs();
150     devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS);
151     EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
152 
153     int64_t addTimeMs = 20;
154     timer->AddRunningTimeMs(addTimeMs);
155     activeTimeMs = timer->GetRunningTimeMs();
156     devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS - addTimeMs);
157     EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
158 
159     timer->AddRunningTimeMs(StatsUtils::DEFAULT_VALUE);
160     EXPECT_EQ(timer->GetRunningTimeMs(), activeTimeMs);
161 
162     timer->Reset();
163     activeTimeMs = timer->GetRunningTimeMs();
164     EXPECT_EQ(activeTimeMs, StatsUtils::DEFAULT_VALUE);
165 }
166 
167 /**
168  * @tc.name: StatsHelper_002
169  * @tc.desc: test class ActiveTimer function
170  * @tc.type: FUNC
171  * @tc.require: issueI5X13X
172  */
173 HWTEST_F (StatsUtilTest, StatsHelper_002, TestSize.Level0)
174 {
175     int64_t activeTimeMs = StatsUtils::DEFAULT_VALUE;
176     int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
177     std::shared_ptr<StatsHelper::ActiveTimer> timer = std::make_shared<StatsHelper::ActiveTimer>();
178     timer->StartRunning();
179     usleep(TIMER_DURATION_MS * US_PER_MS);
180     activeTimeMs = timer->GetRunningTimeMs();
181     devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS);
182     EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
183     timer->StopRunning();
184 
185     timer->Reset();
186     activeTimeMs = timer->GetRunningTimeMs();
187     EXPECT_EQ(activeTimeMs, StatsUtils::DEFAULT_VALUE);
188 }
189 
190 /**
191  * @tc.name: StatsHelper_003
192  * @tc.desc: test class ActiveTimer function
193  * @tc.type: FUNC
194  * @tc.require: issueI5X13X
195  */
196 HWTEST_F (StatsUtilTest, StatsHelper_003, TestSize.Level0)
197 {
198     int64_t activeTimeMs = StatsUtils::DEFAULT_VALUE;
199     int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
200     std::shared_ptr<StatsHelper::ActiveTimer> timer = std::make_shared<StatsHelper::ActiveTimer>();
201     StatsHelper::SetOnBattery(false);
202     EXPECT_FALSE(StatsHelper::IsOnBattery());
203     timer->StartRunning();
204     usleep(TIMER_DURATION_MS * US_PER_MS);
205     StatsHelper::SetOnBattery(true);
206     EXPECT_TRUE(StatsHelper::IsOnBattery());
207     usleep(TIMER_DURATION_MS * US_PER_MS);
208     timer->StopRunning();
209 
210     activeTimeMs = timer->GetRunningTimeMs();
211     devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS);
212     EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
213 
214     timer->Reset();
215     activeTimeMs = timer->GetRunningTimeMs();
216     EXPECT_EQ(activeTimeMs, StatsUtils::DEFAULT_VALUE);
217 }
218 
219 /**
220  * @tc.name: StatsHelper_004
221  * @tc.desc: test class Counter function
222  * @tc.type: FUNC
223  * @tc.require: issueI5X13X
224  */
225 HWTEST_F (StatsUtilTest, StatsHelper_004, TestSize.Level0)
226 {
227     int64_t activeCount = StatsUtils::DEFAULT_VALUE;
228     int64_t addCount = 20;
229     std::shared_ptr<StatsHelper::Counter> counter = std::make_shared<StatsHelper::Counter>();
230     StatsHelper::SetOnBattery(false);
231     EXPECT_FALSE(StatsHelper::IsOnBattery());
232     counter->AddCount(addCount);
233     counter->AddCount(StatsUtils::DEFAULT_VALUE);
234     StatsHelper::SetOnBattery(true);
235     EXPECT_TRUE(StatsHelper::IsOnBattery());
236     counter->AddCount(addCount);
237 
238     activeCount = counter->GetCount();
239     EXPECT_EQ(activeCount, addCount);
240 
241     counter->Reset();
242     activeCount = counter->GetCount();
243     EXPECT_EQ(activeCount, StatsUtils::DEFAULT_VALUE);
244 }
245 
246 /**
247  * @tc.name: StatsHelper_005
248  * @tc.desc: test class Counter function
249  * @tc.type: FUNC
250  * @tc.require: issueI5X13X
251  */
252 HWTEST_F (StatsUtilTest, StatsHelper_005, TestSize.Level0)
253 {
254     StatsHelper::SetOnBattery(false);
255     EXPECT_FALSE(StatsHelper::IsOnBattery());
256     StatsHelper::SetScreenOff(false);
257     EXPECT_FALSE(StatsHelper::IsOnBatteryScreenOff());
258 
259     StatsHelper::SetOnBattery(false);
260     EXPECT_FALSE(StatsHelper::IsOnBattery());
261     StatsHelper::SetScreenOff(true);
262     EXPECT_FALSE(StatsHelper::IsOnBatteryScreenOff());
263 
264     StatsHelper::SetOnBattery(true);
265     EXPECT_TRUE(StatsHelper::IsOnBattery());
266     StatsHelper::SetScreenOff(false);
267     EXPECT_FALSE(StatsHelper::IsOnBatteryScreenOff());
268 
269     StatsHelper::SetOnBattery(true);
270     EXPECT_TRUE(StatsHelper::IsOnBattery());
271     StatsHelper::SetScreenOff(true);
272     EXPECT_TRUE(StatsHelper::IsOnBatteryScreenOff());
273 
274     StatsHelper::SetScreenOff(false);
275 }
276 
277 /**
278  * @tc.name: StatsHelper_006
279  * @tc.desc: test class Counter function
280  * @tc.type: FUNC
281  * @tc.require: issueI5X13X
282  */
283 HWTEST_F (StatsUtilTest, StatsHelper_006, TestSize.Level0)
284 {
285     int64_t timeMs = StatsUtils::DEFAULT_VALUE;
286     int64_t durationTimeMs = StatsUtils::DEFAULT_VALUE;
287     int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
288     StatsHelper::SetOnBattery(false);
289     EXPECT_FALSE(StatsHelper::IsOnBattery());
290     timeMs = StatsHelper::GetOnBatteryUpTimeMs();
291     usleep(TIMER_DURATION_MS * US_PER_MS);
292     durationTimeMs = abs(StatsHelper::GetOnBatteryUpTimeMs() - timeMs);
293     EXPECT_EQ(durationTimeMs, 0);
294 
295     StatsHelper::SetOnBattery(true);
296     EXPECT_TRUE(StatsHelper::IsOnBattery());
297     timeMs = StatsHelper::GetOnBatteryUpTimeMs();
298     usleep(TIMER_DURATION_MS * US_PER_MS);
299     durationTimeMs = abs(StatsHelper::GetOnBatteryUpTimeMs() - timeMs);
300     devTimeMs = abs(durationTimeMs - TIMER_DURATION_MS);
301     EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
302 }
303 
304 /**
305  * @tc.name: StatsParserTest_001
306  * @tc.desc: test Init
307  * @tc.type: FUNC
308  */
309 HWTEST_F (StatsUtilTest, StatsParserTest_001, TestSize.Level0)
310 {
311     auto parser = std::make_shared<BatteryStatsParser>();
312     bool ret = parser->Init();
313     EXPECT_TRUE(ret);
314 }
315 }