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_bluetooth_test.h"
17
18 #include <bluetooth_def.h>
19 #include <hisysevent.h>
20
21 #include "battery_stats_client.h"
22 #include "stats_hisysevent.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::HiviewDFX;
26 using namespace OHOS::PowerMgr;
27 using namespace OHOS;
28 using namespace std;
29
WriteBluetoothEvent(int32_t pid,int32_t uid,long time)30 static void WriteBluetoothEvent(int32_t pid, int32_t uid, long time)
31 {
32 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
33 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
34 int32_t stateScanOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
35 int32_t stateScanOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
36
37 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
38 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
39 usleep(time * StatsTest::US_PER_MS);
40 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
41 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
42
43 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
44 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
45 usleep(time * StatsTest::US_PER_MS);
46 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
47 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
48
49 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
50 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
51 usleep(time * StatsTest::US_PER_MS);
52 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
53 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
54
55 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
56 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateScanOn);
57 usleep(time * StatsTest::US_PER_MS);
58 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
59 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateScanOff);
60 }
61
SetUpTestCase()62 void StatsBluetoothTest::SetUpTestCase()
63 {
64 ParserAveragePowerFile();
65 system("hidumper -s 3302 -a -u");
66 }
67
TearDownTestCase()68 void StatsBluetoothTest::TearDownTestCase()
69 {
70 system("hidumper -s 3302 -a -r");
71 }
72
SetUp()73 void StatsBluetoothTest::SetUp()
74 {
75 auto& statsClient = BatteryStatsClient::GetInstance();
76 statsClient.SetOnBattery(true);
77 }
78
TearDown()79 void StatsBluetoothTest::TearDown()
80 {
81 auto& statsClient = BatteryStatsClient::GetInstance();
82 statsClient.SetOnBattery(false);
83 }
84
85 namespace {
86 /**
87 * @tc.name: StatsBluetoothTest_001
88 * @tc.desc: test Reset function(Bluetooth BR on)
89 * @tc.type: FUNC
90 * @tc.require: issueI5HWJK
91 */
92 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_001, TestSize.Level0)
93 {
94 auto& statsClient = BatteryStatsClient::GetInstance();
95 statsClient.Reset();
96
97 int32_t uid = 10003;
98 int32_t pid = 3458;
99 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
100 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
101 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
102 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
103 usleep(POWER_CONSUMPTION_DURATION_US);
104 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
105 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
106
107 double powerMahBefore = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
108 statsClient.Reset();
109 double powerMahAfter = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
110 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
111 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
112 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
113 }
114
115 /**
116 * @tc.name: StatsBluetoothTest_002
117 * @tc.desc: test GetPartStatsMah function(Bluetooth BR on)
118 * @tc.type: FUNC
119 * @tc.require: issueI5HWJK
120 */
121 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_002, TestSize.Level0)
122 {
123 auto& statsClient = BatteryStatsClient::GetInstance();
124 statsClient.Reset();
125
126 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
127 int32_t uid = 10003;
128 int32_t pid = 3458;
129 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
130 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
131
132 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
133 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
134 usleep(POWER_CONSUMPTION_DURATION_US);
135 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
136 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
137
138 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBrOnAverageMa / US_PER_HOUR;
139 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
140 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
141 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
142 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
143 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
144 }
145
146 /**
147 * @tc.name: StatsBluetoothTest_003
148 * @tc.desc: test GetPartStatsPercent function(Bluetooth BR on)
149 * @tc.type: FUNC
150 * @tc.require: issueI5HWJK
151 */
152 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_003, TestSize.Level0)
153 {
154 auto& statsClient = BatteryStatsClient::GetInstance();
155 statsClient.Reset();
156
157 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
158 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
159 int32_t uid = 10003;
160 int32_t pid = 3458;
161 double fullPercent = 1;
162 double zeroPercent = 0;
163
164 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
165 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
166 usleep(POWER_CONSUMPTION_DURATION_US);
167 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
168 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
169
170 double actualPercent = statsClient.GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
171 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
172 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
173 }
174
175 /**
176 * @tc.name: StatsBluetoothTest_004
177 * @tc.desc: test GetBatteryStats function(Bluetooth BR on)
178 * @tc.type: FUNC
179 * @tc.require: issueI5HWJK
180 */
181 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_004, TestSize.Level0)
182 {
183 auto& statsClient = BatteryStatsClient::GetInstance();
184 statsClient.Reset();
185
186 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
187 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
188 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
189 int32_t uid = 10003;
190 int32_t pid = 3458;
191
192 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
193 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
194 usleep(POWER_CONSUMPTION_DURATION_US);
195 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
196 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
197
198 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBrOnAverageMa / US_PER_HOUR;
199 double actualPower = StatsUtils::DEFAULT_VALUE;
200 auto list = statsClient.GetBatteryStats();
201 for (auto it : list) {
202 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH) {
203 actualPower = (*it).GetPower();
204 }
205 }
206 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
207 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
208 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
209 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
210 }
211
212 /**
213 * @tc.name: StatsBluetoothTest_005
214 * @tc.desc: test BR_SWITCH_STATE event are sent repeatedly, Bluetooth BR power consumption(Bluetooth BR on)
215 * @tc.type: FUNC
216 * @tc.require: issueI5HWJK
217 */
218 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_005, TestSize.Level0)
219 {
220 auto& statsClient = BatteryStatsClient::GetInstance();
221 statsClient.Reset();
222
223 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
224 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
225 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
226 int32_t uid = 10003;
227 int32_t pid = 3458;
228
229 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
230 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
231 usleep(POWER_CONSUMPTION_DURATION_US);
232 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
233 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
234 usleep(POWER_CONSUMPTION_DURATION_US);
235 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
236 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
237 usleep(POWER_CONSUMPTION_DURATION_US);
238 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
239 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
240
241 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBrOnAverageMa / US_PER_HOUR;
242 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
243 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
244 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
245 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
246 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
247 }
248
249 /**
250 * @tc.name: StatsBluetoothTest_006
251 * @tc.desc: test GetAppStatsMah function, Bluetooth BR on state composite test
252 * @tc.type: FUNC
253 * @tc.require: issueI5HWJK
254 */
255 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_006, TestSize.Level0)
256 {
257 auto& statsClient = BatteryStatsClient::GetInstance();
258 statsClient.Reset();
259
260 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
261 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
262 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
263 int32_t stateTurningOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURNING_ON);
264 int32_t stateTurningOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURNING_OFF);
265 int32_t uid = 10003;
266 int32_t pid = 3458;
267
268 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
269 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateTurningOn);
270 usleep(POWER_CONSUMPTION_DURATION_US);
271 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
272 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
273 usleep(POWER_CONSUMPTION_DURATION_US);
274 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
275 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateTurningOff);
276 usleep(POWER_CONSUMPTION_DURATION_US);
277 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
278 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
279
280 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBrOnAverageMa / US_PER_HOUR;
281 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
282 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
283 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
284 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
285 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
286 }
287
288 /**
289 * @tc.name: StatsBluetoothTest_007
290 * @tc.desc: test test GetAppStatsMah function, Bluetooth BR on abnormal state test(Bluetooth BR is off)
291 * @tc.type: FUNC
292 * @tc.require: issueI5HWJK
293 */
294 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_007, TestSize.Level0)
295 {
296 auto& statsClient = BatteryStatsClient::GetInstance();
297 statsClient.Reset();
298
299 int32_t uid = 10003;
300 int32_t pid = 3458;
301 int32_t stateOn = 10;
302 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
303
304 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
305 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
306 usleep(POWER_CONSUMPTION_DURATION_US);
307 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
308 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
309
310 double expectedPower = StatsUtils::DEFAULT_VALUE;
311 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
312 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
313 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
314 EXPECT_EQ(expectedPower, actualPower);
315 }
316
317 /**
318 * @tc.name: StatsBluetoothTest_008
319 * @tc.desc: test test GetAppStatsMah function, Bluetooth BR on abnormal state test(Bluetooth BR is on)
320 * @tc.type: FUNC
321 * @tc.require: issueI5HWJK
322 */
323 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_008, TestSize.Level0)
324 {
325 auto& statsClient = BatteryStatsClient::GetInstance();
326 statsClient.Reset();
327
328 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
329 int32_t uid = 10003;
330 int32_t pid = 3458;
331 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
332 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
333 int32_t stateInvaildOn = 5;
334 int32_t stateInvaildOff = -1;
335
336 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
337 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
338 usleep(POWER_CONSUMPTION_DURATION_US);
339 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
340 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateInvaildOn);
341 usleep(POWER_CONSUMPTION_DURATION_US);
342 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
343 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateInvaildOff);
344 usleep(POWER_CONSUMPTION_DURATION_US);
345 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
346 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
347
348 double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * bluetoothBrOnAverageMa / US_PER_HOUR;
349 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
350 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
351 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
352 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
353 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
354 }
355
356 /**
357 * @tc.name: StatsBluetoothTest_009
358 * @tc.desc: test GetTotalTimeSecond function(Bluetooth BR on)
359 * @tc.type: FUNC
360 * @tc.require: issueI5HWJK
361 */
362 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_009, TestSize.Level0)
363 {
364 auto& statsClient = BatteryStatsClient::GetInstance();
365 statsClient.Reset();
366
367 int32_t uid = 10003;
368 int32_t pid = 3458;
369 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
370 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
371
372 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
373 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
374 usleep(POWER_CONSUMPTION_DURATION_US);
375 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
376 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
377
378 long expectedTime = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
379 long actualTime = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_BLUETOOTH_BR_ON);
380 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
381 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
382 EXPECT_EQ(expectedTime, actualTime);
383 }
384
385 /**
386 * @tc.name: StatsBluetoothTest_010
387 * @tc.desc: test Reset function(Bluetooth BLE on)
388 * @tc.type: FUNC
389 * @tc.require: issueI5HWJK
390 */
391 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_010, TestSize.Level0)
392 {
393 auto& statsClient = BatteryStatsClient::GetInstance();
394 statsClient.Reset();
395
396 int32_t uid = 10003;
397 int32_t pid = 3458;
398 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
399 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
400 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
401 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
402 usleep(POWER_CONSUMPTION_DURATION_US);
403 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
404 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
405
406 double powerMahBefore = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
407 statsClient.Reset();
408 double powerMahAfter = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
409 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
410 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
411 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
412 }
413
414 /**
415 * @tc.name: StatsBluetoothTest_011
416 * @tc.desc: test GetPartStatsMah function(Bluetooth BLE on)
417 * @tc.type: FUNC
418 * @tc.require: issueI5HWJK
419 */
420 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_011, TestSize.Level0)
421 {
422 auto& statsClient = BatteryStatsClient::GetInstance();
423 statsClient.Reset();
424
425 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_ON);
426
427 int32_t uid = 10003;
428 int32_t pid = 3458;
429 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
430 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
431
432 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
433 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
434 usleep(POWER_CONSUMPTION_DURATION_US);
435 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
436 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
437
438 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBleOnAverageMa / US_PER_HOUR;
439 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
440 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
441 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
442 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
443 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
444 }
445
446 /**
447 * @tc.name: StatsBluetoothTest_012
448 * @tc.desc: test GetPartStatsPercent function(Bluetooth BLE on)
449 * @tc.type: FUNC
450 * @tc.require: issueI5HWJK
451 */
452 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_012, TestSize.Level0)
453 {
454 auto& statsClient = BatteryStatsClient::GetInstance();
455 statsClient.Reset();
456
457 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
458 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
459 int32_t uid = 10003;
460 int32_t pid = 3458;
461 double fullPercent = 1;
462 double zeroPercent = 0;
463
464 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
465 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
466 usleep(POWER_CONSUMPTION_DURATION_US);
467 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
468 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
469
470 double actualPercent = statsClient.GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
471 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
472 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
473 }
474
475 /**
476 * @tc.name: StatsBluetoothTest_013
477 * @tc.desc: test GetBatteryStats function(Bluetooth BLE on)
478 * @tc.type: FUNC
479 * @tc.require: issueI5HWJK
480 */
481 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_013, TestSize.Level0)
482 {
483 auto& statsClient = BatteryStatsClient::GetInstance();
484 statsClient.Reset();
485
486 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_ON);
487 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
488 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
489 int32_t uid = 10003;
490 int32_t pid = 3458;
491
492 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
493 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
494 usleep(POWER_CONSUMPTION_DURATION_US);
495 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
496 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
497
498 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBleOnAverageMa / US_PER_HOUR;
499 double actualPower = StatsUtils::DEFAULT_VALUE;
500 auto list = statsClient.GetBatteryStats();
501 for (auto it : list) {
502 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH) {
503 actualPower = (*it).GetPower();
504 }
505 }
506 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
507 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
508 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
509 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
510 }
511
512 /**
513 * @tc.name: StatsBluetoothTest_014
514 * @tc.desc: test BLE_SWITCH_STATE event are sent repeatedly, Bluetooth BLE power consumption(Bluetooth BLE on)
515 * @tc.type: FUNC
516 * @tc.require: issueI5HWJK
517 */
518 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_014, TestSize.Level0)
519 {
520 auto& statsClient = BatteryStatsClient::GetInstance();
521 statsClient.Reset();
522
523 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_ON);
524 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
525 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
526 int32_t uid = 10003;
527 int32_t pid = 3458;
528
529 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
530 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
531 usleep(POWER_CONSUMPTION_DURATION_US);
532 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
533 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
534 usleep(POWER_CONSUMPTION_DURATION_US);
535 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
536 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
537 usleep(POWER_CONSUMPTION_DURATION_US);
538 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
539 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
540
541 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBleOnAverageMa / US_PER_HOUR;
542 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
543 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
544 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
545 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
546 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
547 }
548
549 /**
550 * @tc.name: StatsBluetoothTest_015
551 * @tc.desc: test GetAppStatsMah function, Bluetooth BLE on state composite test
552 * @tc.type: FUNC
553 * @tc.require: issueI5HWJK
554 */
555 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_015, TestSize.Level0)
556 {
557 auto& statsClient = BatteryStatsClient::GetInstance();
558 statsClient.Reset();
559
560 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_ON);
561 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
562 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
563 int32_t stateTurningOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURNING_ON);
564 int32_t stateTurningOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURNING_OFF);
565 int32_t uid = 10003;
566 int32_t pid = 3458;
567
568 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
569 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateTurningOn);
570 usleep(POWER_CONSUMPTION_DURATION_US);
571 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
572 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
573 usleep(POWER_CONSUMPTION_DURATION_US);
574 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
575 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateTurningOff);
576 usleep(POWER_CONSUMPTION_DURATION_US);
577 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
578 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
579
580 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBleOnAverageMa / US_PER_HOUR;
581 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
582 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
583 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
584 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
585 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
586 }
587
588 /**
589 * @tc.name: StatsBluetoothTest_016
590 * @tc.desc: test test GetAppStatsMah function, Bluetooth BLE on abnormal state test(Bluetooth BLE is off)
591 * @tc.type: FUNC
592 * @tc.require: issueI5HWJK
593 */
594 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_016, TestSize.Level0)
595 {
596 auto& statsClient = BatteryStatsClient::GetInstance();
597 statsClient.Reset();
598
599 int32_t uid = 10003;
600 int32_t pid = 3458;
601 int32_t stateOn = 10;
602 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
603
604 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
605 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
606 usleep(POWER_CONSUMPTION_DURATION_US);
607 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
608 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
609
610 double expectedPower = StatsUtils::DEFAULT_VALUE;
611 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
612 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
613 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
614 EXPECT_EQ(expectedPower, actualPower);
615 }
616
617 /**
618 * @tc.name: StatsBluetoothTest_017
619 * @tc.desc: test test GetAppStatsMah function, Bluetooth BLE on abnormal state test(Bluetooth BLE is on)
620 * @tc.type: FUNC
621 * @tc.require: issueI5HWJK
622 */
623 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_017, TestSize.Level0)
624 {
625 auto& statsClient = BatteryStatsClient::GetInstance();
626 statsClient.Reset();
627
628 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_ON);
629 int32_t uid = 10003;
630 int32_t pid = 3458;
631 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
632 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
633 int32_t stateInvaildOn = 5;
634 int32_t stateInvaildOff = -1;
635
636 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
637 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
638 usleep(POWER_CONSUMPTION_DURATION_US);
639 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
640 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateInvaildOn);
641 usleep(POWER_CONSUMPTION_DURATION_US);
642 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
643 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateInvaildOff);
644 usleep(POWER_CONSUMPTION_DURATION_US);
645 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
646 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
647
648 double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * bluetoothBleOnAverageMa / US_PER_HOUR;
649 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
650 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
651 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
652 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
653 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
654 }
655
656 /**
657 * @tc.name: StatsBluetoothTest_018
658 * @tc.desc: test GetTotalTimeSecond function(Bluetooth BLE on)
659 * @tc.type: FUNC
660 * @tc.require: issueI5HWJK
661 */
662 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_018, TestSize.Level0)
663 {
664 auto& statsClient = BatteryStatsClient::GetInstance();
665 statsClient.Reset();
666
667 int32_t uid = 10003;
668 int32_t pid = 3458;
669 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
670 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
671
672 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
673 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
674 usleep(POWER_CONSUMPTION_DURATION_US);
675 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SWITCH_STATE,
676 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
677
678 long expectedTime = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
679 long actualTime = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_BLUETOOTH_BLE_ON);
680 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
681 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
682 EXPECT_EQ(expectedTime, actualTime);
683 }
684
685 /**
686 * @tc.name: StatsBluetoothTest_019
687 * @tc.desc: test Reset function(Bluetooth BR scan)
688 * @tc.type: FUNC
689 * @tc.require: issueI5HWJK
690 */
691 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_019, TestSize.Level0)
692 {
693 auto& statsClient = BatteryStatsClient::GetInstance();
694 statsClient.Reset();
695
696 int32_t uid = 10003;
697 int32_t pid = 3458;
698 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
699 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
700
701 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
702 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
703 usleep(POWER_CONSUMPTION_DURATION_US);
704 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
705 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
706
707 double powerMahBefore = statsClient.GetAppStatsMah(uid);
708 statsClient.Reset();
709 double powerMahAfter = statsClient.GetAppStatsMah(uid);
710 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
711 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
712 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
713 }
714
715 /**
716 * @tc.name: StatsBluetoothTest_020
717 * @tc.desc: test GetAppStatsMah function(Bluetooth BR scan)
718 * @tc.type: FUNC
719 * @tc.require: issueI5HWJK
720 */
721 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_020, TestSize.Level0)
722 {
723 auto& statsClient = BatteryStatsClient::GetInstance();
724 statsClient.Reset();
725
726 double bluetoothBrScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_SCAN);
727 int32_t uid = 10003;
728 int32_t pid = 3458;
729 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
730 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
731
732 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
733 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
734 usleep(POWER_CONSUMPTION_DURATION_US);
735 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
736 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
737
738 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBrScanAverageMa / US_PER_HOUR;
739 double actualPower = statsClient.GetAppStatsMah(uid);
740 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
741 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
742 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
743 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
744 }
745
746 /**
747 * @tc.name: StatsBluetoothTest_021
748 * @tc.desc: test GetAppStatsPercent function(Bluetooth BR scan)
749 * @tc.type: FUNC
750 * @tc.require: issueI5HWJK
751 */
752 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_021, TestSize.Level0)
753 {
754 auto& statsClient = BatteryStatsClient::GetInstance();
755 statsClient.Reset();
756
757 int32_t uid = 10003;
758 int32_t pid = 3458;
759 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
760 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
761 double fullPercent = 1;
762 double zeroPercent = 0;
763
764 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
765 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
766 usleep(POWER_CONSUMPTION_DURATION_US);
767 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
768 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
769
770 double actualPercent = statsClient.GetAppStatsPercent(uid);
771 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
772 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
773 }
774
775 /**
776 * @tc.name: StatsBluetoothTest_022
777 * @tc.desc: test DISCOVERY_STATE event are sent repeatedly, BR scan power consumption(Bluetooth BR scan)
778 * @tc.type: FUNC
779 * @tc.require: issueI5HWJK
780 */
781 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_022, TestSize.Level0)
782 {
783 auto& statsClient = BatteryStatsClient::GetInstance();
784 statsClient.Reset();
785
786 double bluetoothBrScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_SCAN);
787 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
788 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
789 int32_t uid = 10003;
790 int32_t pid = 3458;
791
792 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
793 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
794 usleep(POWER_CONSUMPTION_DURATION_US);
795 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
796 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
797 usleep(POWER_CONSUMPTION_DURATION_US);
798 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
799 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
800 usleep(POWER_CONSUMPTION_DURATION_US);
801 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
802 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
803
804 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBrScanAverageMa / US_PER_HOUR;
805 double actualPower = statsClient.GetAppStatsMah(uid);
806 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
807 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
808 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
809 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
810 }
811
812 /**
813 * @tc.name: StatsBluetoothTest_023
814 * @tc.desc: test GetAppStatsMah function, Bluetooth BR scan state composite test
815 * @tc.type: FUNC
816 * @tc.require: issueI5HWJK
817 */
818 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_023, TestSize.Level0)
819 {
820 auto& statsClient = BatteryStatsClient::GetInstance();
821 statsClient.Reset();
822
823 double bluetoothBrScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_SCAN);
824 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
825 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
826 int32_t stateScan = static_cast<int32_t>(Bluetooth::DISCOVERYING);
827 int32_t uid = 10003;
828 int32_t pid = 3458;
829
830 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
831 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateScan);
832 usleep(POWER_CONSUMPTION_DURATION_US);
833 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
834 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
835 usleep(POWER_CONSUMPTION_DURATION_US);
836 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
837 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateScan);
838 usleep(POWER_CONSUMPTION_DURATION_US);
839 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
840 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
841
842 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBrScanAverageMa / US_PER_HOUR;
843 double actualPower = statsClient.GetAppStatsMah(uid);
844 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
845 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
846 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
847 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
848 }
849
850 /**
851 * @tc.name: StatsBluetoothTest_024
852 * @tc.desc: test test GetAppStatsMah function, Bluetooth BR scan abnormal state test(Bluetooth BR scan is off)
853 * @tc.type: FUNC
854 * @tc.require: issueI5HWJK
855 */
856 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_024, TestSize.Level0)
857 {
858 auto& statsClient = BatteryStatsClient::GetInstance();
859 statsClient.Reset();
860
861 int32_t uid = 10003;
862 int32_t pid = 3458;
863 int32_t stateOn = 10;
864 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
865
866 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
867 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
868 usleep(POWER_CONSUMPTION_DURATION_US);
869 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
870 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
871
872 double expectedPower = StatsUtils::DEFAULT_VALUE;
873 double actualPower = statsClient.GetAppStatsMah(uid);
874 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
875 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
876 EXPECT_EQ(expectedPower, actualPower);
877 }
878
879 /**
880 * @tc.name: StatsBluetoothTest_025
881 * @tc.desc: test test GetAppStatsMah function, Bluetooth BR scan abnormal state test(Bluetooth BR scan is on)
882 * @tc.type: FUNC
883 * @tc.require: issueI5HWJK
884 */
885 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_025, TestSize.Level0)
886 {
887 auto& statsClient = BatteryStatsClient::GetInstance();
888 statsClient.Reset();
889
890 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_SCAN);
891 int32_t uid = 10003;
892 int32_t pid = 3458;
893 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
894 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
895 int32_t stateInvaildOn = 5;
896 int32_t stateInvaildOff = -1;
897
898 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
899 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
900 usleep(POWER_CONSUMPTION_DURATION_US);
901 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
902 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateInvaildOn);
903 usleep(POWER_CONSUMPTION_DURATION_US);
904 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
905 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateInvaildOff);
906 usleep(POWER_CONSUMPTION_DURATION_US);
907 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
908 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
909
910 double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * bluetoothBleOnAverageMa / US_PER_HOUR;
911 double actualPower = statsClient.GetAppStatsMah(uid);
912 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
913 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
914 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
915 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
916 }
917
918 /**
919 * @tc.name: StatsBluetoothTest_026
920 * @tc.desc: test GetTotalTimeSecond function(Bluetooth BR scan)
921 * @tc.type: FUNC
922 * @tc.require: issueI5HWJK
923 */
924 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_026, TestSize.Level0)
925 {
926 auto& statsClient = BatteryStatsClient::GetInstance();
927 statsClient.Reset();
928
929 int32_t uid = 10003;
930 int32_t pid = 3458;
931 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
932 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
933
934 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
935 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
936 usleep(POWER_CONSUMPTION_DURATION_US);
937 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
938 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
939
940 long expectedTime = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
941 long actualTime = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_BLUETOOTH_BR_SCAN, uid);
942 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
943 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
944 EXPECT_EQ(expectedTime, actualTime);
945 }
946
947 /**
948 * @tc.name: StatsBluetoothTest_027
949 * @tc.desc: test GetAppStatsMah function with different UID(Bluetooth BR scan)
950 * @tc.type: FUNC
951 * @tc.require: issueI5HWJK
952 */
953 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_027, TestSize.Level0)
954 {
955 auto& statsClient = BatteryStatsClient::GetInstance();
956 statsClient.Reset();
957
958 double bluetoothBrScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_SCAN);
959 int32_t uidOne = 10003;
960 int32_t pidOne = 3458;
961 int32_t uidTwo = 10004;
962 int32_t pidTwo = 3459;
963 int32_t stateOn = static_cast<int32_t>(Bluetooth::DISCOVERY_STARTED);
964 int32_t stateOff = static_cast<int32_t>(Bluetooth::DISCOVERY_STOPED);
965
966 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
967 HiSysEvent::EventType::STATISTIC, "PID", pidOne, "UID", uidOne, "STATE", stateOn);
968 usleep(POWER_CONSUMPTION_DURATION_US);
969 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
970 HiSysEvent::EventType::STATISTIC, "PID", pidTwo, "UID", uidTwo, "STATE", stateOn);
971 usleep(POWER_CONSUMPTION_DURATION_US);
972 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
973 HiSysEvent::EventType::STATISTIC, "PID", pidTwo, "UID", uidTwo, "STATE", stateOff);
974 usleep(POWER_CONSUMPTION_DURATION_US);
975 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::DISCOVERY_STATE,
976 HiSysEvent::EventType::STATISTIC, "PID", pidOne, "UID", uidOne, "STATE", stateOff);
977
978 double expectedPowerOne = 3 * POWER_CONSUMPTION_DURATION_US * bluetoothBrScanAverageMa / US_PER_HOUR;
979 double actualPowerOne = statsClient.GetAppStatsMah(uidOne);
980 double devPrecentOne = abs(expectedPowerOne - actualPowerOne) / expectedPowerOne;
981 GTEST_LOG_(INFO) << __func__ << ": expected consumption One = " << expectedPowerOne << " mAh";
982 GTEST_LOG_(INFO) << __func__ << ": actual consumption One = " << actualPowerOne << " mAh";
983 EXPECT_LE(devPrecentOne, DEVIATION_PERCENT_THRESHOLD);
984
985 double expectedPowerTwo = POWER_CONSUMPTION_DURATION_US * bluetoothBrScanAverageMa / US_PER_HOUR;
986 double actualPowerTwo = statsClient.GetAppStatsMah(uidTwo);
987 double devPrecentTwo = abs(expectedPowerTwo - actualPowerTwo) / expectedPowerTwo;
988 GTEST_LOG_(INFO) << __func__ << ": expected consumption Two = " << expectedPowerTwo << " mAh";
989 GTEST_LOG_(INFO) << __func__ << ": actual consumption Two = " << actualPowerTwo << " mAh";
990 EXPECT_LE(devPrecentTwo, DEVIATION_PERCENT_THRESHOLD);
991 }
992
993 /**
994 * @tc.name: StatsBluetoothTest_028
995 * @tc.desc: test Reset function(Bluetooth BLE scan)
996 * @tc.type: FUNC
997 * @tc.require: issueI5HWJK
998 */
999 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_028, TestSize.Level0)
1000 {
1001 auto& statsClient = BatteryStatsClient::GetInstance();
1002 statsClient.Reset();
1003
1004 int32_t uid = 10003;
1005 int32_t pid = 3458;
1006
1007 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1008 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1009 usleep(POWER_CONSUMPTION_DURATION_US);
1010 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1011 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1012
1013 double powerMahBefore = statsClient.GetAppStatsMah(uid);
1014 statsClient.Reset();
1015 double powerMahAfter = statsClient.GetAppStatsMah(uid);
1016 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
1017 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
1018 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
1019 }
1020
1021 /**
1022 * @tc.name: StatsBluetoothTest_029
1023 * @tc.desc: test GetAppStatsMah function(Bluetooth BLE scan)
1024 * @tc.type: FUNC
1025 * @tc.require: issueI5HWJK
1026 */
1027 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_029, TestSize.Level0)
1028 {
1029 auto& statsClient = BatteryStatsClient::GetInstance();
1030 statsClient.Reset();
1031
1032 double bluetoothBleScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_SCAN);
1033 int32_t uid = 10003;
1034 int32_t pid = 3458;
1035
1036 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1037 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1038 usleep(POWER_CONSUMPTION_DURATION_US);
1039 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1040 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1041
1042 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBleScanAverageMa / US_PER_HOUR;
1043 double actualPower = statsClient.GetAppStatsMah(uid);
1044 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
1045 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
1046 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
1047 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
1048 }
1049
1050 /**
1051 * @tc.name: StatsBluetoothTest_030
1052 * @tc.desc: test GetAppStatsPercent function(Bluetooth BLE scan)
1053 * @tc.type: FUNC
1054 * @tc.require: issueI5HWJK
1055 */
1056 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_030, TestSize.Level0)
1057 {
1058 auto& statsClient = BatteryStatsClient::GetInstance();
1059 statsClient.Reset();
1060
1061 int32_t uid = 10003;
1062 int32_t pid = 3458;
1063 double fullPercent = 1;
1064 double zeroPercent = 0;
1065
1066 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1067 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1068 usleep(POWER_CONSUMPTION_DURATION_US);
1069 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1070 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1071
1072 double actualPercent = statsClient.GetAppStatsPercent(uid);
1073 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
1074 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
1075 }
1076
1077 /**
1078 * @tc.name: StatsBluetoothTest_031
1079 * @tc.desc: test Bluetooth BLE scan event are sent repeatedly, Bluetooth BLE power consumption(Bluetooth BLE scan)
1080 * @tc.type: FUNC
1081 * @tc.require: issueI5HWJK
1082 */
1083 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_031, TestSize.Level0)
1084 {
1085 auto& statsClient = BatteryStatsClient::GetInstance();
1086 statsClient.Reset();
1087
1088 double bluetoothBleScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_SCAN);
1089 int32_t uid = 10003;
1090 int32_t pid = 3458;
1091
1092 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1093 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1094 usleep(POWER_CONSUMPTION_DURATION_US);
1095 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1096 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1097 usleep(POWER_CONSUMPTION_DURATION_US);
1098 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1099 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1100 usleep(POWER_CONSUMPTION_DURATION_US);
1101 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1102 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1103
1104 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBleScanAverageMa / US_PER_HOUR;
1105 double actualPower = statsClient.GetAppStatsMah(uid);
1106 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
1107 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
1108 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
1109 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
1110 }
1111
1112 /**
1113 * @tc.name: StatsBluetoothTest_032
1114 * @tc.desc: test GetTotalTimeSecond function(Bluetooth BLE scan)
1115 * @tc.type: FUNC
1116 * @tc.require: issueI5HWJK
1117 */
1118 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_032, TestSize.Level0)
1119 {
1120 auto& statsClient = BatteryStatsClient::GetInstance();
1121 statsClient.Reset();
1122
1123 int32_t uid = 10003;
1124 int32_t pid = 3458;
1125
1126 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1127 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1128 usleep(POWER_CONSUMPTION_DURATION_US);
1129 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1130 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid);
1131
1132 long expectedTime = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
1133 long actualTime = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_BLUETOOTH_BLE_SCAN, uid);
1134 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
1135 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
1136 EXPECT_EQ(expectedTime, actualTime);
1137 }
1138
1139 /**
1140 * @tc.name: StatsBluetoothTest_033
1141 * @tc.desc: test GetAppStatsMah function with different UID(Bluetooth BLE scan)
1142 * @tc.type: FUNC
1143 * @tc.require: issueI5HWJK
1144 */
1145 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_033, TestSize.Level0)
1146 {
1147 auto& statsClient = BatteryStatsClient::GetInstance();
1148 statsClient.Reset();
1149
1150 double bluetoothBleScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_SCAN);
1151 int32_t uidOne = 10003;
1152 int32_t pidOne = 3458;
1153 int32_t uidTwo = 10004;
1154 int32_t pidTwo = 3459;
1155
1156 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1157 HiSysEvent::EventType::STATISTIC, "PID", pidOne, "UID", uidOne);
1158 usleep(POWER_CONSUMPTION_DURATION_US);
1159 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_START,
1160 HiSysEvent::EventType::STATISTIC, "PID", pidTwo, "UID", uidTwo);
1161 usleep(POWER_CONSUMPTION_DURATION_US);
1162 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1163 HiSysEvent::EventType::STATISTIC, "PID", pidTwo, "UID", uidTwo);
1164 usleep(POWER_CONSUMPTION_DURATION_US);
1165 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BLE_SCAN_STOP,
1166 HiSysEvent::EventType::STATISTIC, "PID", pidOne, "UID", uidOne);
1167
1168 double expectedPowerOne = 3 * POWER_CONSUMPTION_DURATION_US * bluetoothBleScanAverageMa / US_PER_HOUR;
1169 double actualPowerOne = statsClient.GetAppStatsMah(uidOne);
1170 double devPrecentOne = abs(expectedPowerOne - actualPowerOne) / expectedPowerOne;
1171 GTEST_LOG_(INFO) << __func__ << ": expected consumption One = " << expectedPowerOne << " mAh";
1172 GTEST_LOG_(INFO) << __func__ << ": actual consumption One = " << actualPowerOne << " mAh";
1173 EXPECT_LE(devPrecentOne, DEVIATION_PERCENT_THRESHOLD);
1174
1175 double expectedPowerTwo = POWER_CONSUMPTION_DURATION_US * bluetoothBleScanAverageMa / US_PER_HOUR;
1176 double actualPowerTwo = statsClient.GetAppStatsMah(uidTwo);
1177 double devPrecentTwo = abs(expectedPowerTwo - actualPowerTwo) / expectedPowerTwo;
1178 GTEST_LOG_(INFO) << __func__ << ": expected consumption Two = " << expectedPowerTwo << " mAh";
1179 GTEST_LOG_(INFO) << __func__ << ": actual consumption Two = " << actualPowerTwo << " mAh";
1180 EXPECT_LE(devPrecentTwo, DEVIATION_PERCENT_THRESHOLD);
1181 }
1182
1183 /**
1184 * @tc.name: StatsBluetoothTest_034
1185 * @tc.desc: test GetPartStatsMah function(Bluetooth BR on & BLE on & BR scan & BLE scan)
1186 * @tc.type: FUNC
1187 * @tc.require: issueI5HWJK
1188 */
1189 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_034, TestSize.Level0)
1190 {
1191 auto& statsClient = BatteryStatsClient::GetInstance();
1192 statsClient.Reset();
1193
1194 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
1195 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_ON);
1196 double bluetoothBrScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_SCAN);
1197 double bluetoothBleScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_SCAN);
1198 long testTimeMs = 200;
1199 int32_t uid = 10003;
1200 int32_t pid = 3458;
1201
1202 WriteBluetoothEvent(pid, uid, testTimeMs);
1203
1204 double expectedPartPower = testTimeMs * (bluetoothBrOnAverageMa + bluetoothBleOnAverageMa) / MS_PER_HOUR;
1205 double actualPartPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
1206 double devPrecentPart = abs(expectedPartPower - actualPartPower) / expectedPartPower;
1207 GTEST_LOG_(INFO) << __func__ << ": expected part consumption = " << expectedPartPower << " mAh";
1208 GTEST_LOG_(INFO) << __func__ << ": actual part consumption = " << actualPartPower << " mAh";
1209 EXPECT_LE(devPrecentPart, DEVIATION_PERCENT_THRESHOLD);
1210
1211 double expectedSoftPower = testTimeMs * (bluetoothBrScanAverageMa + bluetoothBleScanAverageMa) / MS_PER_HOUR;
1212 double actualSoftPower = statsClient.GetAppStatsMah(uid);
1213 double devPrecentSoft = abs(expectedSoftPower - actualSoftPower) / expectedSoftPower;
1214 GTEST_LOG_(INFO) << __func__ << ": expected soft consumption = " << expectedSoftPower << " mAh";
1215 GTEST_LOG_(INFO) << __func__ << ": actual soft consumption = " << actualSoftPower << " mAh";
1216 EXPECT_LE(devPrecentSoft, DEVIATION_PERCENT_THRESHOLD);
1217 }
1218
1219 /**
1220 * @tc.name: StatsBluetoothTest_035
1221 * @tc.desc: test SetOnBattery function(Bluetooth BR on & BLE on & BR scan & BLE scan)
1222 * @tc.type: FUNC
1223 * @tc.require: issueI5HWJK
1224 */
1225 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_035, TestSize.Level0)
1226 {
1227 auto& statsClient = BatteryStatsClient::GetInstance();
1228 statsClient.Reset();
1229 statsClient.SetOnBattery(false);
1230
1231 long testTimeMs = 200;
1232 int32_t uid = 10003;
1233 int32_t pid = 3458;
1234
1235 WriteBluetoothEvent(pid, uid, testTimeMs);
1236
1237 double expectedPower = StatsUtils::DEFAULT_VALUE;
1238 double actualPartPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
1239 GTEST_LOG_(INFO) << __func__ << ": expected part consumption = " << expectedPower << " mAh";
1240 GTEST_LOG_(INFO) << __func__ << ": actual part consumption = " << actualPartPower << " mAh";
1241 EXPECT_EQ(expectedPower, actualPartPower);
1242
1243 double actualSoftPower = statsClient.GetAppStatsMah(uid);
1244 GTEST_LOG_(INFO) << __func__ << ": expected soft consumption = " << expectedPower << " mAh";
1245 GTEST_LOG_(INFO) << __func__ << ": actual soft consumption = " << actualSoftPower << " mAh";
1246 EXPECT_EQ(expectedPower, actualSoftPower);
1247 statsClient.SetOnBattery(true);
1248 }
1249
1250 /**
1251 * @tc.name: StatsBluetoothTest_036
1252 * @tc.desc: test GetPartStatsMah function with battery changed(Bluetooth BR on)
1253 * @tc.type: FUNC
1254 * @tc.require: issueI5HWJK
1255 */
1256 HWTEST_F (StatsBluetoothTest, StatsBluetoothTest_036, TestSize.Level0)
1257 {
1258 auto& statsClient = BatteryStatsClient::GetInstance();
1259 statsClient.Reset();
1260
1261 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
1262 int32_t uid = 10003;
1263 int32_t pid = 3458;
1264 int32_t stateOn = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_ON);
1265 int32_t stateOff = static_cast<int32_t>(Bluetooth::BTStateID::STATE_TURN_OFF);
1266
1267 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
1268 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
1269 usleep(POWER_CONSUMPTION_DURATION_US);
1270 statsClient.SetOnBattery(false);
1271 usleep(POWER_CONSUMPTION_DURATION_US);
1272 statsClient.SetOnBattery(true);
1273 usleep(POWER_CONSUMPTION_DURATION_US);
1274 HiSysEventWrite(HiSysEvent::Domain::BT_SERVICE, StatsHiSysEvent::BR_SWITCH_STATE,
1275 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
1276
1277 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * bluetoothBrOnAverageMa / US_PER_HOUR;
1278 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
1279 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
1280 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
1281 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
1282 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
1283 }
1284 }