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