1 /****************************************************************************** 2 * 3 * Copyright (C) 2016 Google, Inc. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 #include <chrono> 19 #include <cstdint> 20 #include <string> 21 #include <thread> 22 #include <vector> 23 24 #include <gmock/gmock.h> 25 #include <gtest/gtest.h> 26 27 #include <base/logging.h> 28 29 #include "osi/include/metrics.h" 30 #include "osi/include/time.h" 31 #include "src/protos/bluetooth.pb.h" 32 33 #define BTM_COD_MAJOR_AUDIO_TEST 0x04 34 35 namespace testing { 36 37 using clearcut::connectivity::A2DPSession; 38 using clearcut::connectivity::BluetoothLog; 39 using clearcut::connectivity::BluetoothSession; 40 using clearcut::connectivity::BluetoothSession_ConnectionTechnologyType; 41 using clearcut::connectivity::BluetoothSession_DisconnectReasonType; 42 using clearcut::connectivity::DeviceInfo; 43 using clearcut::connectivity::DeviceInfo_DeviceType; 44 using clearcut::connectivity::PairEvent; 45 using clearcut::connectivity::RFCommSession; 46 using clearcut::connectivity::ScanEvent; 47 using clearcut::connectivity::ScanEvent_ScanTechnologyType; 48 using clearcut::connectivity::ScanEvent_ScanEventType; 49 using clearcut::connectivity::WakeEvent; 50 using clearcut::connectivity::WakeEvent_WakeEventType; 51 using system_bt_osi::BluetoothMetricsLogger; 52 using system_bt_osi::A2dpSessionMetrics; 53 54 namespace { 55 const size_t kMaxEventGenerationLimit = 5000; 56 } 57 58 /* 59 * Get current OS boot time in ms 60 */ 61 static int64_t time_get_os_boottime_ms(void) { 62 return time_get_os_boottime_us() / 1000; 63 } 64 65 static void sleep_ms(int64_t t) { 66 std::this_thread::sleep_for(std::chrono::milliseconds(t)); 67 } 68 69 DeviceInfo* MakeDeviceInfo(int32_t device_class, 70 DeviceInfo_DeviceType device_type) { 71 DeviceInfo* info = new DeviceInfo(); 72 info->set_device_class(device_class); 73 info->set_device_type(device_type); 74 return info; 75 } 76 77 PairEvent* MakePairEvent(int32_t disconnect_reason, int64_t timestamp_ms, 78 DeviceInfo* device_info) { 79 PairEvent* event = new PairEvent(); 80 event->set_disconnect_reason(disconnect_reason); 81 event->set_event_time_millis(timestamp_ms); 82 if (device_info) event->set_allocated_device_paired_with(device_info); 83 return event; 84 } 85 86 WakeEvent* MakeWakeEvent(WakeEvent_WakeEventType event_type, 87 const std::string& requestor, const std::string& name, 88 int64_t timestamp_ms) { 89 WakeEvent* event = new WakeEvent(); 90 event->set_wake_event_type(event_type); 91 event->set_requestor(requestor); 92 event->set_name(name); 93 event->set_event_time_millis(timestamp_ms); 94 return event; 95 } 96 97 ScanEvent* MakeScanEvent(ScanEvent_ScanEventType event_type, 98 const std::string& initiator, 99 ScanEvent_ScanTechnologyType tech_type, 100 int32_t num_results, int64_t timestamp_ms) { 101 ScanEvent* event = new ScanEvent(); 102 event->set_scan_event_type(event_type); 103 event->set_initiator(initiator); 104 event->set_scan_technology_type(tech_type); 105 event->set_number_results(num_results); 106 event->set_event_time_millis(timestamp_ms); 107 return event; 108 } 109 110 A2DPSession* MakeA2DPSession(const A2dpSessionMetrics& metrics) { 111 A2DPSession* session = new A2DPSession(); 112 session->set_media_timer_min_millis(metrics.media_timer_min_ms); 113 session->set_media_timer_max_millis(metrics.media_timer_max_ms); 114 session->set_media_timer_avg_millis(metrics.media_timer_avg_ms); 115 session->set_buffer_overruns_max_count(metrics.buffer_overruns_max_count); 116 session->set_buffer_overruns_total(metrics.buffer_overruns_total); 117 session->set_buffer_underruns_average(metrics.buffer_underruns_average); 118 session->set_buffer_underruns_count(metrics.buffer_underruns_count); 119 session->set_audio_duration_millis(metrics.audio_duration_ms); 120 return session; 121 } 122 123 BluetoothSession* MakeBluetoothSession( 124 int64_t session_duration_sec, 125 BluetoothSession_ConnectionTechnologyType conn_type, 126 BluetoothSession_DisconnectReasonType disconnect_reason, 127 DeviceInfo* device_info, RFCommSession* rfcomm_session, 128 A2DPSession* a2dp_session) { 129 BluetoothSession* session = new BluetoothSession(); 130 if (a2dp_session) session->set_allocated_a2dp_session(a2dp_session); 131 if (rfcomm_session) session->set_allocated_rfcomm_session(rfcomm_session); 132 if (device_info) session->set_allocated_device_connected_to(device_info); 133 session->set_session_duration_sec(session_duration_sec); 134 session->set_connection_technology_type(conn_type); 135 session->set_disconnect_reason_type(disconnect_reason); 136 return session; 137 } 138 139 BluetoothLog* MakeBluetoothLog(std::vector<BluetoothSession*> bt_sessions, 140 std::vector<PairEvent*> pair_events, 141 std::vector<WakeEvent*> wake_events, 142 std::vector<ScanEvent*> scan_events) { 143 BluetoothLog* bt_log = new BluetoothLog(); 144 for (BluetoothSession* session : bt_sessions) { 145 bt_log->mutable_session()->AddAllocated(session); 146 } 147 bt_sessions.clear(); 148 for (PairEvent* event : pair_events) { 149 bt_log->mutable_pair_event()->AddAllocated(event); 150 } 151 pair_events.clear(); 152 for (WakeEvent* event : wake_events) { 153 bt_log->mutable_wake_event()->AddAllocated(event); 154 } 155 wake_events.clear(); 156 for (ScanEvent* event : scan_events) { 157 bt_log->mutable_scan_event()->AddAllocated(event); 158 } 159 scan_events.clear(); 160 return bt_log; 161 } 162 163 void GenerateWakeEvents(size_t start, size_t end, 164 std::vector<WakeEvent*>* wake_events) { 165 for (size_t i = start; i < end; ++i) { 166 wake_events->push_back(MakeWakeEvent( 167 i % 2 == 0 ? WakeEvent_WakeEventType::WakeEvent_WakeEventType_ACQUIRED 168 : WakeEvent_WakeEventType::WakeEvent_WakeEventType_RELEASED, 169 "TEST_REQ", "TEST_NAME", i)); 170 } 171 } 172 173 #define COMPARE_A2DP_METRICS(a, b) \ 174 do { \ 175 EXPECT_EQ(a.audio_duration_ms, b.audio_duration_ms); \ 176 EXPECT_EQ(a.media_timer_min_ms, b.media_timer_min_ms); \ 177 EXPECT_EQ(a.media_timer_max_ms, b.media_timer_max_ms); \ 178 EXPECT_EQ(a.media_timer_avg_ms, b.media_timer_avg_ms); \ 179 EXPECT_EQ(a.total_scheduling_count, b.total_scheduling_count); \ 180 EXPECT_EQ(a.buffer_overruns_max_count, b.buffer_overruns_max_count); \ 181 EXPECT_EQ(a.buffer_overruns_total, b.buffer_overruns_total); \ 182 EXPECT_THAT(a.buffer_underruns_average, \ 183 FloatNear(b.buffer_underruns_average, 0.01)); \ 184 a.buffer_underruns_average = b.buffer_underruns_average; \ 185 EXPECT_EQ(a.buffer_underruns_count, b.buffer_underruns_count); \ 186 } while (0) 187 188 /* 189 * metrics_sum = metrics1 + metrics2 190 */ 191 TEST(BluetoothA2DPSessionMetricsTest, TestUpdateNormal) { 192 A2dpSessionMetrics metrics1; 193 A2dpSessionMetrics metrics2; 194 A2dpSessionMetrics metrics_sum; 195 metrics1.audio_duration_ms = 10; 196 metrics2.audio_duration_ms = 25; 197 metrics_sum.audio_duration_ms = 35; 198 metrics1.media_timer_min_ms = 10; 199 metrics2.media_timer_min_ms = 25; 200 metrics_sum.media_timer_min_ms = 10; 201 metrics1.media_timer_max_ms = 100; 202 metrics2.media_timer_max_ms = 200; 203 metrics_sum.media_timer_max_ms = 200; 204 metrics1.media_timer_avg_ms = 50; 205 metrics1.total_scheduling_count = 50; 206 metrics2.media_timer_avg_ms = 100; 207 metrics2.total_scheduling_count = 50; 208 metrics_sum.media_timer_avg_ms = 75; 209 metrics_sum.total_scheduling_count = 100; 210 metrics1.buffer_overruns_max_count = 70; 211 metrics2.buffer_overruns_max_count = 80; 212 metrics_sum.buffer_overruns_max_count = 80; 213 metrics1.buffer_underruns_average = 80; 214 metrics1.buffer_underruns_count = 1200; 215 metrics2.buffer_underruns_average = 130; 216 metrics2.buffer_underruns_count = 2400; 217 metrics_sum.buffer_underruns_average = 113.33333333; 218 metrics_sum.buffer_underruns_count = 3600; 219 metrics1.Update(metrics2); 220 COMPARE_A2DP_METRICS(metrics1, metrics_sum); 221 EXPECT_TRUE(metrics1 == metrics_sum); 222 EXPECT_EQ(metrics1, metrics_sum); 223 } 224 225 TEST(BluetoothA2DPSessionMetricsTest, TestUpdateNew) { 226 A2dpSessionMetrics metrics1; 227 A2dpSessionMetrics metrics2; 228 A2dpSessionMetrics metrics_sum; 229 metrics2.audio_duration_ms = 25; 230 metrics_sum.audio_duration_ms = 25; 231 metrics2.media_timer_min_ms = 25; 232 metrics_sum.media_timer_min_ms = 25; 233 metrics2.media_timer_max_ms = 200; 234 metrics_sum.media_timer_max_ms = 200; 235 metrics2.media_timer_avg_ms = 100; 236 metrics2.total_scheduling_count = 50; 237 metrics_sum.media_timer_avg_ms = 100; 238 metrics_sum.total_scheduling_count = 50; 239 metrics2.buffer_overruns_max_count = 80; 240 metrics_sum.buffer_overruns_max_count = 80; 241 metrics2.buffer_underruns_average = 130; 242 metrics2.buffer_underruns_count = 2400; 243 metrics_sum.buffer_underruns_average = 130; 244 metrics_sum.buffer_underruns_count = 2400; 245 metrics1.Update(metrics2); 246 COMPARE_A2DP_METRICS(metrics1, metrics_sum); 247 EXPECT_TRUE(metrics1 == metrics_sum); 248 EXPECT_EQ(metrics1, metrics_sum); 249 } 250 251 TEST(BluetoothA2DPSessionMetricsTest, TestNullUpdate) { 252 A2dpSessionMetrics metrics1; 253 A2dpSessionMetrics metrics2; 254 A2dpSessionMetrics metrics_sum; 255 metrics2.audio_duration_ms = 25; 256 metrics_sum.audio_duration_ms = 25; 257 metrics2.media_timer_min_ms = 25; 258 metrics_sum.media_timer_min_ms = 25; 259 metrics2.media_timer_max_ms = 200; 260 metrics_sum.media_timer_max_ms = 200; 261 metrics2.media_timer_avg_ms = 100; 262 metrics2.total_scheduling_count = 50; 263 metrics_sum.media_timer_avg_ms = 100; 264 metrics_sum.total_scheduling_count = 50; 265 metrics2.buffer_overruns_max_count = 80; 266 metrics_sum.buffer_overruns_max_count = 80; 267 metrics2.buffer_underruns_average = 130; 268 metrics2.buffer_underruns_count = 2400; 269 metrics_sum.buffer_underruns_average = 130; 270 metrics_sum.buffer_underruns_count = 2400; 271 metrics2.Update(metrics1); 272 COMPARE_A2DP_METRICS(metrics2, metrics_sum); 273 EXPECT_TRUE(metrics2 == metrics_sum); 274 EXPECT_EQ(metrics2, metrics_sum); 275 } 276 277 TEST(BluetoothA2DPSessionMetricsTest, TestPartialUpdate) { 278 A2dpSessionMetrics metrics1; 279 A2dpSessionMetrics metrics2; 280 A2dpSessionMetrics metrics_sum; 281 metrics1.audio_duration_ms = 10; 282 metrics2.audio_duration_ms = 25; 283 metrics_sum.audio_duration_ms = 35; 284 metrics1.media_timer_min_ms = 10; 285 metrics_sum.media_timer_min_ms = 10; 286 metrics1.media_timer_max_ms = 100; 287 metrics_sum.media_timer_max_ms = 100; 288 metrics1.media_timer_avg_ms = 50; 289 metrics1.total_scheduling_count = 50; 290 metrics2.media_timer_avg_ms = 100; 291 metrics_sum.media_timer_avg_ms = 50; 292 metrics_sum.total_scheduling_count = 50; 293 metrics1.buffer_overruns_max_count = 70; 294 metrics_sum.buffer_overruns_max_count = 70; 295 metrics1.buffer_underruns_average = 80; 296 metrics1.buffer_underruns_count = 1200; 297 metrics2.buffer_underruns_count = 2400; 298 metrics_sum.buffer_underruns_average = 80; 299 metrics_sum.buffer_underruns_count = 1200; 300 metrics1.Update(metrics2); 301 COMPARE_A2DP_METRICS(metrics1, metrics_sum); 302 EXPECT_TRUE(metrics1 == metrics_sum); 303 EXPECT_EQ(metrics1, metrics_sum); 304 } 305 306 class BluetoothMetricsLoggerTest : public Test { 307 protected: 308 // Use to hold test protos 309 std::vector<PairEvent*> pair_events_; 310 std::vector<WakeEvent*> wake_events_; 311 std::vector<ScanEvent*> scan_events_; 312 std::vector<BluetoothSession*> bt_sessions_; 313 int64_t num_pair_event_ = 0; 314 int64_t num_wake_event_ = 0; 315 int64_t num_scan_event_ = 0; 316 int64_t num_bt_session_ = 0; 317 BluetoothLog* bt_log_; 318 std::string bt_log_str_; 319 std::string bt_log_ascii_str_; 320 321 void UpdateLog() { 322 for (BluetoothSession* session : bt_sessions_) { 323 bt_log_->mutable_session()->AddAllocated(session); 324 } 325 if (num_bt_session_ > 0) { 326 bt_log_->set_num_bluetooth_session(num_bt_session_); 327 } else if (bt_sessions_.size() > 0) { 328 bt_log_->set_num_bluetooth_session(bt_sessions_.size()); 329 } 330 bt_sessions_.clear(); 331 for (PairEvent* event : pair_events_) { 332 bt_log_->mutable_pair_event()->AddAllocated(event); 333 } 334 if (num_pair_event_ > 0) { 335 bt_log_->set_num_pair_event(num_pair_event_); 336 } else if (pair_events_.size() > 0) { 337 bt_log_->set_num_pair_event(pair_events_.size()); 338 } 339 pair_events_.clear(); 340 for (WakeEvent* event : wake_events_) { 341 bt_log_->mutable_wake_event()->AddAllocated(event); 342 } 343 if (num_wake_event_ > 0) { 344 bt_log_->set_num_wake_event(num_wake_event_); 345 } else if (wake_events_.size() > 0) { 346 bt_log_->set_num_wake_event(wake_events_.size()); 347 } 348 wake_events_.clear(); 349 for (ScanEvent* event : scan_events_) { 350 bt_log_->mutable_scan_event()->AddAllocated(event); 351 } 352 if (num_scan_event_ > 0) { 353 bt_log_->set_num_scan_event(num_scan_event_); 354 } else if (scan_events_.size() > 0) { 355 bt_log_->set_num_scan_event(scan_events_.size()); 356 } 357 scan_events_.clear(); 358 bt_log_->SerializeToString(&bt_log_str_); 359 } 360 361 void ClearLog() { 362 for (BluetoothSession* session : bt_sessions_) { 363 session->Clear(); 364 delete session; 365 } 366 bt_sessions_.clear(); 367 for (PairEvent* event : pair_events_) { 368 event->Clear(); 369 delete event; 370 } 371 pair_events_.clear(); 372 for (WakeEvent* event : wake_events_) { 373 event->Clear(); 374 delete event; 375 } 376 wake_events_.clear(); 377 for (ScanEvent* event : scan_events_) { 378 event->Clear(); 379 delete event; 380 } 381 scan_events_.clear(); 382 bt_log_->Clear(); 383 } 384 385 void SetUp() { 386 bt_log_ = new BluetoothLog(); 387 // Clear existing metrics entries, if any 388 BluetoothMetricsLogger::GetInstance()->Reset(); 389 } 390 void TearDown() { 391 // Clear remaining metrics entries, if any 392 BluetoothMetricsLogger::GetInstance()->Reset(); 393 ClearLog(); 394 delete bt_log_; 395 } 396 397 public: 398 }; 399 400 TEST_F(BluetoothMetricsLoggerTest, PairEventTest) { 401 pair_events_.push_back(MakePairEvent( 402 35, 12345, 403 MakeDeviceInfo( 404 42, DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR))); 405 UpdateLog(); 406 BluetoothMetricsLogger::GetInstance()->LogPairEvent( 407 35, 12345, 42, system_bt_osi::DEVICE_TYPE_BREDR); 408 std::string msg_str; 409 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 410 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 411 } 412 413 TEST_F(BluetoothMetricsLoggerTest, WakeEventTest) { 414 wake_events_.push_back( 415 MakeWakeEvent(WakeEvent_WakeEventType::WakeEvent_WakeEventType_ACQUIRED, 416 "TEST_REQ", "TEST_NAME", 12345)); 417 UpdateLog(); 418 BluetoothMetricsLogger::GetInstance()->LogWakeEvent( 419 system_bt_osi::WAKE_EVENT_ACQUIRED, "TEST_REQ", "TEST_NAME", 12345); 420 std::string msg_str; 421 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 422 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 423 } 424 425 TEST_F(BluetoothMetricsLoggerTest, WakeEventOverrunTest) { 426 GenerateWakeEvents( 427 kMaxEventGenerationLimit - BluetoothMetricsLogger::kMaxNumWakeEvent, 428 kMaxEventGenerationLimit, &wake_events_); 429 num_wake_event_ = kMaxEventGenerationLimit; 430 UpdateLog(); 431 for (size_t i = 0; i < kMaxEventGenerationLimit; ++i) { 432 BluetoothMetricsLogger::GetInstance()->LogWakeEvent( 433 i % 2 == 0 ? system_bt_osi::WAKE_EVENT_ACQUIRED 434 : system_bt_osi::WAKE_EVENT_RELEASED, 435 "TEST_REQ", "TEST_NAME", i); 436 } 437 std::string msg_str; 438 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 439 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 440 } 441 442 TEST_F(BluetoothMetricsLoggerTest, ScanEventTest) { 443 scan_events_.push_back(MakeScanEvent( 444 ScanEvent_ScanEventType::ScanEvent_ScanEventType_SCAN_EVENT_STOP, 445 "TEST_INITIATOR", ScanEvent_ScanTechnologyType:: 446 ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_BREDR, 447 42, 123456)); 448 UpdateLog(); 449 BluetoothMetricsLogger::GetInstance()->LogScanEvent( 450 false, "TEST_INITIATOR", system_bt_osi::SCAN_TECH_TYPE_BREDR, 42, 123456); 451 std::string msg_str; 452 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 453 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 454 } 455 456 TEST_F(BluetoothMetricsLoggerTest, BluetoothSessionTest) { 457 bt_sessions_.push_back(MakeBluetoothSession( 458 10, 459 BluetoothSession_ConnectionTechnologyType:: 460 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE, 461 BluetoothSession_DisconnectReasonType:: 462 BluetoothSession_DisconnectReasonType_UNKNOWN, 463 nullptr, nullptr, nullptr)); 464 UpdateLog(); 465 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( 466 system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_LE, 123456); 467 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( 468 system_bt_osi::DISCONNECT_REASON_UNKNOWN, 133456); 469 std::string msg_str; 470 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 471 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 472 } 473 474 TEST_F(BluetoothMetricsLoggerTest, BluetoothSessionDumpBeforeEndTest) { 475 bt_sessions_.push_back(MakeBluetoothSession( 476 1, 477 BluetoothSession_ConnectionTechnologyType:: 478 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE, 479 BluetoothSession_DisconnectReasonType:: 480 BluetoothSession_DisconnectReasonType_METRICS_DUMP, 481 nullptr, nullptr, nullptr)); 482 UpdateLog(); 483 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( 484 system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_LE, time_get_os_boottime_ms()); 485 sleep_ms(1000); 486 std::string msg_str; 487 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 488 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 489 } 490 491 TEST_F(BluetoothMetricsLoggerTest, BluetoothSessionStartBeforeEndTest) { 492 bt_sessions_.push_back(MakeBluetoothSession( 493 1, 494 BluetoothSession_ConnectionTechnologyType:: 495 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_UNKNOWN, 496 BluetoothSession_DisconnectReasonType:: 497 BluetoothSession_DisconnectReasonType_NEXT_START_WITHOUT_END_PREVIOUS, 498 nullptr, nullptr, nullptr)); 499 bt_sessions_.push_back(MakeBluetoothSession( 500 2, 501 BluetoothSession_ConnectionTechnologyType:: 502 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE, 503 BluetoothSession_DisconnectReasonType:: 504 BluetoothSession_DisconnectReasonType_METRICS_DUMP, 505 nullptr, nullptr, nullptr)); 506 UpdateLog(); 507 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( 508 system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_UNKNOWN, 0); 509 sleep_ms(1000); 510 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( 511 system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_LE, 0); 512 sleep_ms(2000); 513 std::string msg_str; 514 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 515 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 516 } 517 518 /* 519 * Test Case: A2DPSessionTwoUpdatesTest 520 * 521 * 1. Create Instance 522 * 2. LogBluetoothSessionStart 523 * 3. LogBluetoothSessionDeviceInfo 524 * 4. LogA2dpSession 525 * 5. LogA2dpSession 526 * 6. LogBluetoothSessionEnd 527 * 7. WriteString 528 * 529 */ 530 TEST_F(BluetoothMetricsLoggerTest, A2DPSessionTwoUpdatesTest) { 531 /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ 532 A2dpSessionMetrics metrics1; 533 A2dpSessionMetrics metrics2; 534 A2dpSessionMetrics metrics_sum; 535 metrics1.audio_duration_ms = 10; 536 metrics2.audio_duration_ms = 25; 537 metrics_sum.audio_duration_ms = 35; 538 metrics1.media_timer_min_ms = 10; 539 metrics2.media_timer_min_ms = 25; 540 metrics_sum.media_timer_min_ms = 10; 541 metrics1.media_timer_max_ms = 100; 542 metrics2.media_timer_max_ms = 200; 543 metrics_sum.media_timer_max_ms = 200; 544 metrics1.media_timer_avg_ms = 50; 545 metrics1.total_scheduling_count = 50; 546 metrics2.media_timer_avg_ms = 100; 547 metrics2.total_scheduling_count = 50; 548 metrics_sum.media_timer_avg_ms = 75; 549 metrics_sum.total_scheduling_count = 100; 550 metrics1.buffer_overruns_max_count = 70; 551 metrics2.buffer_overruns_max_count = 80; 552 metrics_sum.buffer_overruns_max_count = 80; 553 metrics1.buffer_underruns_average = 80; 554 metrics1.buffer_underruns_count = 1200; 555 metrics2.buffer_underruns_average = 130; 556 metrics2.buffer_underruns_count = 2400; 557 metrics_sum.buffer_underruns_average = 113.33333333; 558 metrics_sum.buffer_underruns_count = 3600; 559 DeviceInfo* info = MakeDeviceInfo( 560 BTM_COD_MAJOR_AUDIO_TEST, 561 DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); 562 A2DPSession* session = MakeA2DPSession(metrics_sum); 563 bt_sessions_.push_back(MakeBluetoothSession( 564 10, 565 BluetoothSession_ConnectionTechnologyType:: 566 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, 567 BluetoothSession_DisconnectReasonType:: 568 BluetoothSession_DisconnectReasonType_UNKNOWN, 569 info, nullptr, session)); 570 UpdateLog(); 571 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( 572 system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 123456); 573 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionDeviceInfo( 574 BTM_COD_MAJOR_AUDIO_TEST, system_bt_osi::DEVICE_TYPE_BREDR); 575 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); 576 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); 577 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( 578 system_bt_osi::DISCONNECT_REASON_UNKNOWN, 133456); 579 std::string msg_str; 580 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 581 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 582 } 583 584 /* 585 * Test Case: A2DPSessionTwoUpdatesSeparatedbyDumpTest 586 * 587 * 1. Create Instance 588 * 2. LogBluetoothSessionStart 589 * 3. LogBluetoothSessionDeviceInfo 590 * 4. LogA2dpSession 591 * 5. WriteString 592 * 6. LogA2dpSession 593 * 7. LogBluetoothSessionEnd 594 * 8. WriteString 595 * 596 */ 597 TEST_F(BluetoothMetricsLoggerTest, A2DPSessionTwoUpdatesSeparatedbyDumpTest) { 598 /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ 599 A2dpSessionMetrics metrics1; 600 A2dpSessionMetrics metrics2; 601 metrics1.audio_duration_ms = 10; 602 metrics2.audio_duration_ms = 25; 603 metrics1.media_timer_min_ms = 10; 604 metrics2.media_timer_min_ms = 25; 605 metrics1.media_timer_max_ms = 100; 606 metrics2.media_timer_max_ms = 200; 607 metrics1.media_timer_avg_ms = 50; 608 metrics1.total_scheduling_count = 50; 609 metrics2.media_timer_avg_ms = 100; 610 metrics2.total_scheduling_count = 50; 611 metrics1.buffer_overruns_max_count = 70; 612 metrics2.buffer_overruns_max_count = 80; 613 metrics1.buffer_underruns_average = 80; 614 metrics1.buffer_underruns_count = 1200; 615 metrics2.buffer_underruns_average = 130; 616 metrics2.buffer_underruns_count = 2400; 617 DeviceInfo* info = MakeDeviceInfo( 618 BTM_COD_MAJOR_AUDIO_TEST, 619 DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); 620 A2DPSession* session = MakeA2DPSession(metrics1); 621 bt_sessions_.push_back(MakeBluetoothSession( 622 1, 623 BluetoothSession_ConnectionTechnologyType:: 624 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, 625 BluetoothSession_DisconnectReasonType:: 626 BluetoothSession_DisconnectReasonType_METRICS_DUMP, 627 info, nullptr, session)); 628 UpdateLog(); 629 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( 630 system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 0); 631 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionDeviceInfo( 632 BTM_COD_MAJOR_AUDIO_TEST, system_bt_osi::DEVICE_TYPE_BREDR); 633 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); 634 sleep_ms(1000); 635 std::string msg_str; 636 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 637 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 638 ClearLog(); 639 info = MakeDeviceInfo( 640 BTM_COD_MAJOR_AUDIO_TEST, 641 DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); 642 session = MakeA2DPSession(metrics2); 643 bt_sessions_.push_back(MakeBluetoothSession( 644 1, 645 BluetoothSession_ConnectionTechnologyType:: 646 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, 647 BluetoothSession_DisconnectReasonType:: 648 BluetoothSession_DisconnectReasonType_UNKNOWN, 649 info, nullptr, session)); 650 UpdateLog(); 651 sleep_ms(1000); 652 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); 653 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( 654 system_bt_osi::DISCONNECT_REASON_UNKNOWN, 0); 655 msg_str.clear(); 656 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 657 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 658 } 659 660 /* 661 * Test Case 1: A2DPSessionOnlyTest 662 * 663 * 1. Create Instance 664 * 4. LogA2dpSession 665 * 5. WriteString 666 * 6. LogA2dpSession 667 * 8. WriteString 668 * 669 */ 670 TEST_F(BluetoothMetricsLoggerTest, A2DPSessionOnlyTest) { 671 /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ 672 A2dpSessionMetrics metrics1; 673 A2dpSessionMetrics metrics2; 674 A2dpSessionMetrics metrics_sum; 675 metrics1.audio_duration_ms = 10; 676 metrics2.audio_duration_ms = 25; 677 metrics_sum.audio_duration_ms = 35; 678 metrics1.media_timer_min_ms = 10; 679 metrics2.media_timer_min_ms = 25; 680 metrics_sum.media_timer_min_ms = 10; 681 metrics1.media_timer_max_ms = 100; 682 metrics2.media_timer_max_ms = 200; 683 metrics_sum.media_timer_max_ms = 200; 684 metrics1.media_timer_avg_ms = 50; 685 metrics1.total_scheduling_count = 50; 686 metrics2.media_timer_avg_ms = 100; 687 metrics2.total_scheduling_count = 50; 688 metrics_sum.media_timer_avg_ms = 75; 689 metrics_sum.total_scheduling_count = 100; 690 metrics1.buffer_overruns_max_count = 70; 691 metrics2.buffer_overruns_max_count = 80; 692 metrics_sum.buffer_overruns_max_count = 80; 693 metrics1.buffer_underruns_average = 80; 694 metrics1.buffer_underruns_count = 1200; 695 metrics2.buffer_underruns_average = 130; 696 metrics2.buffer_underruns_count = 2400; 697 metrics_sum.buffer_underruns_average = 113.33333333; 698 metrics_sum.buffer_underruns_count = 3600; 699 DeviceInfo* info = MakeDeviceInfo( 700 BTM_COD_MAJOR_AUDIO_TEST, 701 DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); 702 A2DPSession* session = MakeA2DPSession(metrics_sum); 703 bt_sessions_.push_back(MakeBluetoothSession( 704 1, 705 BluetoothSession_ConnectionTechnologyType:: 706 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, 707 BluetoothSession_DisconnectReasonType:: 708 BluetoothSession_DisconnectReasonType_METRICS_DUMP, 709 info, nullptr, session)); 710 UpdateLog(); 711 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); 712 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); 713 sleep_ms(1000); 714 std::string msg_str; 715 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 716 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 717 } 718 719 /* 720 * Test Case: A2DPSessionDumpBeforeTwoUpdatesTest 721 * 722 * 1. Create Instance 723 * 2. LogBluetoothSessionStart 724 * 3. LogBluetoothSessionDeviceInfo 725 * 5. WriteString 726 * 6. LogA2dpSession 727 * 7. LogA2dpSession 728 * 8. LogBluetoothSessionEnd 729 * 9. WriteString 730 * 731 */ 732 TEST_F(BluetoothMetricsLoggerTest, A2DPSessionDumpBeforeTwoUpdatesTest) { 733 /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ 734 A2dpSessionMetrics metrics1; 735 A2dpSessionMetrics metrics2; 736 A2dpSessionMetrics metrics_sum; 737 metrics1.audio_duration_ms = 10; 738 metrics2.audio_duration_ms = 25; 739 metrics_sum.audio_duration_ms = 35; 740 metrics1.media_timer_min_ms = 10; 741 metrics2.media_timer_min_ms = 25; 742 metrics_sum.media_timer_min_ms = 10; 743 metrics1.media_timer_max_ms = 100; 744 metrics2.media_timer_max_ms = 200; 745 metrics_sum.media_timer_max_ms = 200; 746 metrics1.media_timer_avg_ms = 50; 747 metrics1.total_scheduling_count = 50; 748 metrics2.media_timer_avg_ms = 100; 749 metrics2.total_scheduling_count = 50; 750 metrics_sum.media_timer_avg_ms = 75; 751 metrics_sum.total_scheduling_count = 100; 752 metrics1.buffer_overruns_max_count = 70; 753 metrics2.buffer_overruns_max_count = 80; 754 metrics_sum.buffer_overruns_max_count = 80; 755 metrics1.buffer_underruns_average = 80; 756 metrics1.buffer_underruns_count = 1200; 757 metrics2.buffer_underruns_average = 130; 758 metrics2.buffer_underruns_count = 2400; 759 metrics_sum.buffer_underruns_average = 113.33333333; 760 metrics_sum.buffer_underruns_count = 3600; 761 DeviceInfo* info = MakeDeviceInfo( 762 BTM_COD_MAJOR_AUDIO_TEST, 763 DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); 764 bt_sessions_.push_back(MakeBluetoothSession( 765 1, 766 BluetoothSession_ConnectionTechnologyType:: 767 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, 768 BluetoothSession_DisconnectReasonType:: 769 BluetoothSession_DisconnectReasonType_METRICS_DUMP, 770 info, nullptr, nullptr)); 771 UpdateLog(); 772 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( 773 system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 0); 774 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionDeviceInfo( 775 BTM_COD_MAJOR_AUDIO_TEST, system_bt_osi::DEVICE_TYPE_BREDR); 776 sleep_ms(1000); 777 std::string msg_str; 778 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 779 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 780 ClearLog(); 781 info = MakeDeviceInfo( 782 BTM_COD_MAJOR_AUDIO_TEST, 783 DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); 784 A2DPSession* session = MakeA2DPSession(metrics_sum); 785 bt_sessions_.push_back(MakeBluetoothSession( 786 1, 787 BluetoothSession_ConnectionTechnologyType:: 788 BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, 789 BluetoothSession_DisconnectReasonType:: 790 BluetoothSession_DisconnectReasonType_UNKNOWN, 791 info, nullptr, session)); 792 UpdateLog(); 793 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); 794 BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); 795 sleep_ms(1000); 796 BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( 797 system_bt_osi::DISCONNECT_REASON_UNKNOWN, 0); 798 msg_str.clear(); 799 BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str, true); 800 EXPECT_THAT(msg_str, StrEq(bt_log_str_)); 801 } 802 } 803
