Home | History | Annotate | Download | only in test
      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