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