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