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