| /****************************************************************************** |
| * |
| * Copyright 2016 Google, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| #include <chrono> |
| #include <cstdint> |
| #include <string> |
| #include <thread> |
| #include <vector> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include <base/logging.h> |
| #include <include/hardware/bt_av.h> |
| |
| #include "bluetooth/metrics/bluetooth.pb.h" |
| #include "osi/include/metrics.h" |
| #include "osi/include/time.h" |
| |
| #define BTM_COD_MAJOR_AUDIO_TEST 0x04 |
| |
| namespace testing { |
| |
| using bluetooth::metrics::BluetoothMetricsProto::A2DPSession; |
| using bluetooth::metrics::BluetoothMetricsProto::A2dpSourceCodec; |
| using bluetooth::metrics::BluetoothMetricsProto::BluetoothLog; |
| using bluetooth::metrics::BluetoothMetricsProto::BluetoothSession; |
| using bluetooth::metrics::BluetoothMetricsProto:: |
| BluetoothSession_ConnectionTechnologyType; |
| using bluetooth::metrics::BluetoothMetricsProto:: |
| BluetoothSession_DisconnectReasonType; |
| using bluetooth::metrics::BluetoothMetricsProto::DeviceInfo; |
| using bluetooth::metrics::BluetoothMetricsProto::DeviceInfo_DeviceType; |
| using bluetooth::metrics::BluetoothMetricsProto::PairEvent; |
| using bluetooth::metrics::BluetoothMetricsProto::RFCommSession; |
| using bluetooth::metrics::BluetoothMetricsProto::ScanEvent; |
| using bluetooth::metrics::BluetoothMetricsProto::ScanEvent_ScanTechnologyType; |
| using bluetooth::metrics::BluetoothMetricsProto::ScanEvent_ScanEventType; |
| using bluetooth::metrics::BluetoothMetricsProto::WakeEvent; |
| using bluetooth::metrics::BluetoothMetricsProto::WakeEvent_WakeEventType; |
| using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType; |
| using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileConnectionStats; |
| using system_bt_osi::BluetoothMetricsLogger; |
| using system_bt_osi::A2dpSessionMetrics; |
| |
| namespace { |
| const size_t kMaxEventGenerationLimit = 5000; |
| } |
| |
| /* |
| * Get current OS boot time in ms |
| */ |
| static int64_t time_get_os_boottime_ms(void) { |
| return time_get_os_boottime_us() / 1000; |
| } |
| |
| static void sleep_ms(int64_t t) { |
| std::this_thread::sleep_for(std::chrono::milliseconds(t)); |
| } |
| |
| DeviceInfo* MakeDeviceInfo(int32_t device_class, |
| DeviceInfo_DeviceType device_type) { |
| DeviceInfo* info = new DeviceInfo(); |
| info->set_device_class(device_class); |
| info->set_device_type(device_type); |
| return info; |
| } |
| |
| PairEvent* MakePairEvent(int32_t disconnect_reason, int64_t timestamp_ms, |
| DeviceInfo* device_info) { |
| PairEvent* event = new PairEvent(); |
| event->set_disconnect_reason(disconnect_reason); |
| event->set_event_time_millis(timestamp_ms); |
| if (device_info) event->set_allocated_device_paired_with(device_info); |
| return event; |
| } |
| |
| WakeEvent* MakeWakeEvent(WakeEvent_WakeEventType event_type, |
| const std::string& requestor, const std::string& name, |
| int64_t timestamp_ms) { |
| WakeEvent* event = new WakeEvent(); |
| event->set_wake_event_type(event_type); |
| event->set_requestor(requestor); |
| event->set_name(name); |
| event->set_event_time_millis(timestamp_ms); |
| return event; |
| } |
| |
| ScanEvent* MakeScanEvent(ScanEvent_ScanEventType event_type, |
| const std::string& initiator, |
| ScanEvent_ScanTechnologyType tech_type, |
| int32_t num_results, int64_t timestamp_ms) { |
| ScanEvent* event = new ScanEvent(); |
| event->set_scan_event_type(event_type); |
| event->set_initiator(initiator); |
| event->set_scan_technology_type(tech_type); |
| event->set_number_results(num_results); |
| event->set_event_time_millis(timestamp_ms); |
| return event; |
| } |
| |
| A2DPSession* MakeA2DPSession(const A2dpSessionMetrics& metrics, |
| A2dpSourceCodec source_codec) { |
| A2DPSession* session = new A2DPSession(); |
| session->set_media_timer_min_millis(metrics.media_timer_min_ms); |
| session->set_media_timer_max_millis(metrics.media_timer_max_ms); |
| session->set_media_timer_avg_millis(metrics.media_timer_avg_ms); |
| session->set_buffer_overruns_max_count(metrics.buffer_overruns_max_count); |
| session->set_buffer_overruns_total(metrics.buffer_overruns_total); |
| session->set_buffer_underruns_average(metrics.buffer_underruns_average); |
| session->set_buffer_underruns_count(metrics.buffer_underruns_count); |
| session->set_audio_duration_millis(metrics.audio_duration_ms); |
| session->set_source_codec(source_codec); |
| session->set_is_a2dp_offload(metrics.is_a2dp_offload); |
| return session; |
| } |
| |
| BluetoothSession* MakeBluetoothSession( |
| int64_t session_duration_sec, |
| BluetoothSession_ConnectionTechnologyType conn_type, |
| BluetoothSession_DisconnectReasonType disconnect_reason, |
| DeviceInfo* device_info, RFCommSession* rfcomm_session, |
| A2DPSession* a2dp_session) { |
| BluetoothSession* session = new BluetoothSession(); |
| if (a2dp_session) session->set_allocated_a2dp_session(a2dp_session); |
| if (rfcomm_session) session->set_allocated_rfcomm_session(rfcomm_session); |
| if (device_info) session->set_allocated_device_connected_to(device_info); |
| session->set_session_duration_sec(session_duration_sec); |
| session->set_connection_technology_type(conn_type); |
| session->set_disconnect_reason_type(disconnect_reason); |
| return session; |
| } |
| |
| BluetoothLog* MakeBluetoothLog(std::vector<BluetoothSession*> bt_sessions, |
| std::vector<PairEvent*> pair_events, |
| std::vector<WakeEvent*> wake_events, |
| std::vector<ScanEvent*> scan_events) { |
| BluetoothLog* bt_log = new BluetoothLog(); |
| for (BluetoothSession* session : bt_sessions) { |
| bt_log->mutable_session()->AddAllocated(session); |
| } |
| bt_sessions.clear(); |
| for (PairEvent* event : pair_events) { |
| bt_log->mutable_pair_event()->AddAllocated(event); |
| } |
| pair_events.clear(); |
| for (WakeEvent* event : wake_events) { |
| bt_log->mutable_wake_event()->AddAllocated(event); |
| } |
| wake_events.clear(); |
| for (ScanEvent* event : scan_events) { |
| bt_log->mutable_scan_event()->AddAllocated(event); |
| } |
| scan_events.clear(); |
| return bt_log; |
| } |
| |
| void GenerateWakeEvents(size_t start, size_t end, |
| std::vector<WakeEvent*>* wake_events) { |
| for (size_t i = start; i < end; ++i) { |
| wake_events->push_back(MakeWakeEvent( |
| i % 2 == 0 ? WakeEvent_WakeEventType::WakeEvent_WakeEventType_ACQUIRED |
| : WakeEvent_WakeEventType::WakeEvent_WakeEventType_RELEASED, |
| "TEST_REQ", "TEST_NAME", i)); |
| } |
| } |
| |
| #define COMPARE_A2DP_METRICS(a, b) \ |
| do { \ |
| EXPECT_EQ((a).audio_duration_ms, (b).audio_duration_ms); \ |
| EXPECT_EQ((a).media_timer_min_ms, (b).media_timer_min_ms); \ |
| EXPECT_EQ((a).media_timer_max_ms, (b).media_timer_max_ms); \ |
| EXPECT_EQ((a).media_timer_avg_ms, (b).media_timer_avg_ms); \ |
| EXPECT_EQ((a).total_scheduling_count, (b).total_scheduling_count); \ |
| EXPECT_EQ((a).buffer_overruns_max_count, (b).buffer_overruns_max_count); \ |
| EXPECT_EQ((a).buffer_overruns_total, (b).buffer_overruns_total); \ |
| EXPECT_THAT((a).buffer_underruns_average, \ |
| FloatNear((b).buffer_underruns_average, 0.01)); \ |
| (a).buffer_underruns_average = (b).buffer_underruns_average; \ |
| EXPECT_EQ((a).buffer_underruns_count, (b).buffer_underruns_count); \ |
| EXPECT_EQ((a).codec_index, (b).codec_index); \ |
| EXPECT_EQ((a).is_a2dp_offload, (b).is_a2dp_offload); \ |
| } while (0) |
| |
| /* |
| * metrics_sum = metrics1 + metrics2 |
| */ |
| TEST(BluetoothA2DPSessionMetricsTest, TestUpdateNormal) { |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| A2dpSessionMetrics metrics_sum; |
| metrics1.audio_duration_ms = 10; |
| metrics2.audio_duration_ms = 25; |
| metrics_sum.audio_duration_ms = 35; |
| metrics1.media_timer_min_ms = 10; |
| metrics2.media_timer_min_ms = 25; |
| metrics_sum.media_timer_min_ms = 10; |
| metrics1.media_timer_max_ms = 100; |
| metrics2.media_timer_max_ms = 200; |
| metrics_sum.media_timer_max_ms = 200; |
| metrics1.media_timer_avg_ms = 50; |
| metrics1.total_scheduling_count = 50; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics_sum.media_timer_avg_ms = 75; |
| metrics_sum.total_scheduling_count = 100; |
| metrics1.buffer_overruns_max_count = 70; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics_sum.buffer_overruns_max_count = 80; |
| metrics1.buffer_underruns_average = 80; |
| metrics1.buffer_underruns_count = 1200; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics_sum.buffer_underruns_average = 113.33333333; |
| metrics_sum.buffer_underruns_count = 3600; |
| metrics1.codec_index = -1; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| metrics_sum.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| metrics1.is_a2dp_offload = false; |
| metrics2.is_a2dp_offload = true; |
| metrics_sum.is_a2dp_offload = true; |
| metrics1.Update(metrics2); |
| COMPARE_A2DP_METRICS(metrics1, metrics_sum); |
| EXPECT_TRUE(metrics1 == metrics_sum); |
| EXPECT_EQ(metrics1, metrics_sum); |
| } |
| |
| TEST(BluetoothA2DPSessionMetricsTest, TestUpdateNew) { |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| A2dpSessionMetrics metrics_sum; |
| metrics2.audio_duration_ms = 25; |
| metrics_sum.audio_duration_ms = 25; |
| metrics2.media_timer_min_ms = 25; |
| metrics_sum.media_timer_min_ms = 25; |
| metrics2.media_timer_max_ms = 200; |
| metrics_sum.media_timer_max_ms = 200; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics_sum.media_timer_avg_ms = 100; |
| metrics_sum.total_scheduling_count = 50; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics_sum.buffer_overruns_max_count = 80; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics_sum.buffer_underruns_average = 130; |
| metrics_sum.buffer_underruns_count = 2400; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_APTX; |
| metrics_sum.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_APTX; |
| metrics2.is_a2dp_offload = true; |
| metrics_sum.is_a2dp_offload = true; |
| metrics1.Update(metrics2); |
| COMPARE_A2DP_METRICS(metrics1, metrics_sum); |
| EXPECT_TRUE(metrics1 == metrics_sum); |
| EXPECT_EQ(metrics1, metrics_sum); |
| } |
| |
| TEST(BluetoothA2DPSessionMetricsTest, TestNullUpdate) { |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| A2dpSessionMetrics metrics_sum; |
| metrics2.audio_duration_ms = 25; |
| metrics_sum.audio_duration_ms = 25; |
| metrics2.media_timer_min_ms = 25; |
| metrics_sum.media_timer_min_ms = 25; |
| metrics2.media_timer_max_ms = 200; |
| metrics_sum.media_timer_max_ms = 200; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics_sum.media_timer_avg_ms = 100; |
| metrics_sum.total_scheduling_count = 50; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics_sum.buffer_overruns_max_count = 80; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics_sum.buffer_underruns_average = 130; |
| metrics_sum.buffer_underruns_count = 2400; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD; |
| metrics_sum.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD; |
| metrics2.is_a2dp_offload = true; |
| metrics_sum.is_a2dp_offload = true; |
| metrics2.Update(metrics1); |
| COMPARE_A2DP_METRICS(metrics2, metrics_sum); |
| EXPECT_TRUE(metrics2 == metrics_sum); |
| EXPECT_EQ(metrics2, metrics_sum); |
| } |
| |
| TEST(BluetoothA2DPSessionMetricsTest, TestPartialUpdate) { |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| A2dpSessionMetrics metrics_sum; |
| metrics1.audio_duration_ms = 10; |
| metrics2.audio_duration_ms = 25; |
| metrics_sum.audio_duration_ms = 35; |
| metrics1.media_timer_min_ms = 10; |
| metrics_sum.media_timer_min_ms = 10; |
| metrics1.media_timer_max_ms = 100; |
| metrics_sum.media_timer_max_ms = 100; |
| metrics1.media_timer_avg_ms = 50; |
| metrics1.total_scheduling_count = 50; |
| metrics2.media_timer_avg_ms = 100; |
| metrics_sum.media_timer_avg_ms = 50; |
| metrics_sum.total_scheduling_count = 50; |
| metrics1.buffer_overruns_max_count = 70; |
| metrics_sum.buffer_overruns_max_count = 70; |
| metrics1.buffer_underruns_average = 80; |
| metrics1.buffer_underruns_count = 1200; |
| metrics2.buffer_underruns_count = 2400; |
| metrics_sum.buffer_underruns_average = 80; |
| metrics_sum.buffer_underruns_count = 1200; |
| metrics1.Update(metrics2); |
| COMPARE_A2DP_METRICS(metrics1, metrics_sum); |
| EXPECT_TRUE(metrics1 == metrics_sum); |
| EXPECT_EQ(metrics1, metrics_sum); |
| } |
| |
| class BluetoothMetricsLoggerTest : public Test { |
| protected: |
| // Use to hold test protos |
| std::vector<PairEvent*> pair_events_; |
| std::vector<WakeEvent*> wake_events_; |
| std::vector<ScanEvent*> scan_events_; |
| std::vector<BluetoothSession*> bt_sessions_; |
| int64_t num_pair_event_ = 0; |
| int64_t num_wake_event_ = 0; |
| int64_t num_scan_event_ = 0; |
| int64_t num_bt_session_ = 0; |
| BluetoothLog* bt_log_; |
| std::string bt_log_str_; |
| std::string bt_log_ascii_str_; |
| |
| void UpdateLog() { |
| for (BluetoothSession* session : bt_sessions_) { |
| bt_log_->mutable_session()->AddAllocated(session); |
| } |
| if (num_bt_session_ > 0) { |
| bt_log_->set_num_bluetooth_session(num_bt_session_); |
| } else if (bt_sessions_.size() > 0) { |
| bt_log_->set_num_bluetooth_session(bt_sessions_.size()); |
| } |
| bt_sessions_.clear(); |
| for (PairEvent* event : pair_events_) { |
| bt_log_->mutable_pair_event()->AddAllocated(event); |
| } |
| if (num_pair_event_ > 0) { |
| bt_log_->set_num_pair_event(num_pair_event_); |
| } else if (pair_events_.size() > 0) { |
| bt_log_->set_num_pair_event(pair_events_.size()); |
| } |
| pair_events_.clear(); |
| for (WakeEvent* event : wake_events_) { |
| bt_log_->mutable_wake_event()->AddAllocated(event); |
| } |
| if (num_wake_event_ > 0) { |
| bt_log_->set_num_wake_event(num_wake_event_); |
| } else if (wake_events_.size() > 0) { |
| bt_log_->set_num_wake_event(wake_events_.size()); |
| } |
| wake_events_.clear(); |
| for (ScanEvent* event : scan_events_) { |
| bt_log_->mutable_scan_event()->AddAllocated(event); |
| } |
| if (num_scan_event_ > 0) { |
| bt_log_->set_num_scan_event(num_scan_event_); |
| } else if (scan_events_.size() > 0) { |
| bt_log_->set_num_scan_event(scan_events_.size()); |
| } |
| scan_events_.clear(); |
| bt_log_->SerializeToString(&bt_log_str_); |
| } |
| |
| void ClearLog() { |
| for (BluetoothSession* session : bt_sessions_) { |
| session->Clear(); |
| delete session; |
| } |
| bt_sessions_.clear(); |
| for (PairEvent* event : pair_events_) { |
| event->Clear(); |
| delete event; |
| } |
| pair_events_.clear(); |
| for (WakeEvent* event : wake_events_) { |
| event->Clear(); |
| delete event; |
| } |
| wake_events_.clear(); |
| for (ScanEvent* event : scan_events_) { |
| event->Clear(); |
| delete event; |
| } |
| scan_events_.clear(); |
| bt_log_->Clear(); |
| } |
| |
| void SetUp() { |
| bt_log_ = new BluetoothLog(); |
| // Clear existing metrics entries, if any |
| BluetoothMetricsLogger::GetInstance()->Reset(); |
| } |
| void TearDown() { |
| // Clear remaining metrics entries, if any |
| BluetoothMetricsLogger::GetInstance()->Reset(); |
| ClearLog(); |
| delete bt_log_; |
| } |
| |
| public: |
| }; |
| |
| TEST_F(BluetoothMetricsLoggerTest, PairEventTest) { |
| pair_events_.push_back(MakePairEvent( |
| 35, 12345, |
| MakeDeviceInfo( |
| 42, DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR))); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogPairEvent( |
| 35, 12345, 42, system_bt_osi::DEVICE_TYPE_BREDR); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, WakeEventTest) { |
| wake_events_.push_back( |
| MakeWakeEvent(WakeEvent_WakeEventType::WakeEvent_WakeEventType_ACQUIRED, |
| "TEST_REQ", "TEST_NAME", 12345)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogWakeEvent( |
| system_bt_osi::WAKE_EVENT_ACQUIRED, "TEST_REQ", "TEST_NAME", 12345); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, WakeEventOverrunTest) { |
| GenerateWakeEvents( |
| kMaxEventGenerationLimit - BluetoothMetricsLogger::kMaxNumWakeEvent, |
| kMaxEventGenerationLimit, &wake_events_); |
| num_wake_event_ = kMaxEventGenerationLimit; |
| UpdateLog(); |
| for (size_t i = 0; i < kMaxEventGenerationLimit; ++i) { |
| BluetoothMetricsLogger::GetInstance()->LogWakeEvent( |
| i % 2 == 0 ? system_bt_osi::WAKE_EVENT_ACQUIRED |
| : system_bt_osi::WAKE_EVENT_RELEASED, |
| "TEST_REQ", "TEST_NAME", i); |
| } |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, ScanEventTest) { |
| scan_events_.push_back(MakeScanEvent( |
| ScanEvent_ScanEventType::ScanEvent_ScanEventType_SCAN_EVENT_STOP, |
| "TEST_INITIATOR", ScanEvent_ScanTechnologyType:: |
| ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_BREDR, |
| 42, 123456)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogScanEvent( |
| false, "TEST_INITIATOR", system_bt_osi::SCAN_TECH_TYPE_BREDR, 42, 123456); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, BluetoothSessionTest) { |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 10, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_UNKNOWN, |
| nullptr, nullptr, nullptr)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_LE, 123456); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( |
| system_bt_osi::DISCONNECT_REASON_UNKNOWN, 133456); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, BluetoothSessionDumpBeforeEndTest) { |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_METRICS_DUMP, |
| nullptr, nullptr, nullptr)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_LE, time_get_os_boottime_ms()); |
| sleep_ms(1000); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, BluetoothSessionStartBeforeEndTest) { |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_UNKNOWN, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_NEXT_START_WITHOUT_END_PREVIOUS, |
| nullptr, nullptr, nullptr)); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 2, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_METRICS_DUMP, |
| nullptr, nullptr, nullptr)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_UNKNOWN, 0); |
| sleep_ms(1000); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_LE, 0); |
| sleep_ms(2000); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| /* |
| * Test Case: A2DPSessionTwoUpdatesTest |
| * |
| * 1. Create Instance |
| * 2. LogBluetoothSessionStart |
| * 3. LogBluetoothSessionDeviceInfo |
| * 4. LogA2dpSession |
| * 5. LogA2dpSession |
| * 6. LogBluetoothSessionEnd |
| * 7. WriteString |
| * |
| */ |
| TEST_F(BluetoothMetricsLoggerTest, A2DPSessionTwoUpdatesTest) { |
| /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| A2dpSessionMetrics metrics_sum; |
| metrics1.audio_duration_ms = 10; |
| metrics2.audio_duration_ms = 25; |
| metrics_sum.audio_duration_ms = 35; |
| metrics1.media_timer_min_ms = 10; |
| metrics2.media_timer_min_ms = 25; |
| metrics_sum.media_timer_min_ms = 10; |
| metrics1.media_timer_max_ms = 100; |
| metrics2.media_timer_max_ms = 200; |
| metrics_sum.media_timer_max_ms = 200; |
| metrics1.media_timer_avg_ms = 50; |
| metrics1.total_scheduling_count = 50; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics_sum.media_timer_avg_ms = 75; |
| metrics_sum.total_scheduling_count = 100; |
| metrics1.buffer_overruns_max_count = 70; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics_sum.buffer_overruns_max_count = 80; |
| metrics1.buffer_underruns_average = 80; |
| metrics1.buffer_underruns_count = 1200; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics_sum.buffer_underruns_average = 113.33333333; |
| metrics_sum.buffer_underruns_count = 3600; |
| metrics1.codec_index = -1; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| metrics_sum.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| metrics1.is_a2dp_offload = false; |
| metrics2.is_a2dp_offload = true; |
| metrics_sum.is_a2dp_offload = true; |
| DeviceInfo* info = MakeDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, |
| DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); |
| A2DPSession* session = |
| MakeA2DPSession(metrics_sum, A2dpSourceCodec::A2DP_SOURCE_CODEC_AAC); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 10, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_UNKNOWN, |
| info, nullptr, session)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 123456); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, system_bt_osi::DEVICE_TYPE_BREDR); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( |
| system_bt_osi::DISCONNECT_REASON_UNKNOWN, 133456); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| /* |
| * Test Case: A2DPSessionTwoUpdatesSeparatedbyDumpTest |
| * |
| * 1. Create Instance |
| * 2. LogBluetoothSessionStart |
| * 3. LogBluetoothSessionDeviceInfo |
| * 4. LogA2dpSession |
| * 5. WriteString |
| * 6. LogA2dpSession |
| * 7. LogBluetoothSessionEnd |
| * 8. WriteString |
| * |
| */ |
| TEST_F(BluetoothMetricsLoggerTest, A2DPSessionTwoUpdatesSeparatedbyDumpTest) { |
| /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| metrics1.audio_duration_ms = 10; |
| metrics2.audio_duration_ms = 25; |
| metrics1.media_timer_min_ms = 10; |
| metrics2.media_timer_min_ms = 25; |
| metrics1.media_timer_max_ms = 100; |
| metrics2.media_timer_max_ms = 200; |
| metrics1.media_timer_avg_ms = 50; |
| metrics1.total_scheduling_count = 50; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics1.buffer_overruns_max_count = 70; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics1.buffer_underruns_average = 80; |
| metrics1.buffer_underruns_count = 1200; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics1.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_SBC; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| DeviceInfo* info = MakeDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, |
| DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); |
| A2DPSession* session = |
| MakeA2DPSession(metrics1, A2dpSourceCodec::A2DP_SOURCE_CODEC_SBC); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_METRICS_DUMP, |
| info, nullptr, session)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 0); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, system_bt_osi::DEVICE_TYPE_BREDR); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); |
| sleep_ms(1000); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| ClearLog(); |
| info = MakeDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, |
| DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); |
| session = MakeA2DPSession(metrics2, A2dpSourceCodec::A2DP_SOURCE_CODEC_AAC); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_UNKNOWN, |
| info, nullptr, session)); |
| UpdateLog(); |
| sleep_ms(1000); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( |
| system_bt_osi::DISCONNECT_REASON_UNKNOWN, 0); |
| msg_str.clear(); |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| /* |
| * Test Case: A2DPSessionTwoUpdatesSeparatedbyEndTest |
| * |
| * 1. Create Instance |
| * 2. LogBluetoothSessionStart |
| * 3. LogA2dpSession |
| * 4. LogBluetoothSessionEnd |
| * 5. LogBluetoothSessionStart |
| * 6. LogA2dpSession |
| * 7. LogBluetoothSessionEnd |
| * 8. WriteString |
| * |
| */ |
| TEST_F(BluetoothMetricsLoggerTest, A2DPSessionTwoUpdatesSeparatedbyEndTest) { |
| /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ |
| A2dpSessionMetrics metrics1; |
| metrics1.audio_duration_ms = 10; |
| metrics1.media_timer_min_ms = 10; |
| metrics1.media_timer_max_ms = 100; |
| metrics1.media_timer_avg_ms = 50; |
| metrics1.total_scheduling_count = 50; |
| metrics1.buffer_overruns_max_count = 70; |
| metrics1.buffer_underruns_average = 80; |
| metrics1.buffer_underruns_count = 1200; |
| metrics1.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_SBC; |
| DeviceInfo* info = MakeDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, |
| DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); |
| A2DPSession* session = |
| MakeA2DPSession(metrics1, A2dpSourceCodec::A2DP_SOURCE_CODEC_SBC); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_UNKNOWN, |
| info, nullptr, session)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 0); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, system_bt_osi::DEVICE_TYPE_BREDR); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); |
| sleep_ms(1000); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( |
| system_bt_osi::DISCONNECT_REASON_UNKNOWN, 0); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| ClearLog(); |
| A2dpSessionMetrics metrics2; |
| metrics2.audio_duration_ms = 25; |
| metrics2.media_timer_min_ms = 25; |
| metrics2.media_timer_max_ms = 200; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| session = MakeA2DPSession(metrics2, A2dpSourceCodec::A2DP_SOURCE_CODEC_AAC); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_UNKNOWN, |
| nullptr, nullptr, session)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 0); |
| sleep_ms(1000); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( |
| system_bt_osi::DISCONNECT_REASON_UNKNOWN, 0); |
| msg_str.clear(); |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| /* |
| * Test Case 1: A2DPSessionOnlyTest |
| * |
| * 1. Create Instance |
| * 4. LogA2dpSession |
| * 5. WriteString |
| * 6. LogA2dpSession |
| * 8. WriteString |
| * |
| */ |
| TEST_F(BluetoothMetricsLoggerTest, A2DPSessionOnlyTest) { |
| /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| A2dpSessionMetrics metrics_sum; |
| metrics1.audio_duration_ms = 10; |
| metrics2.audio_duration_ms = 25; |
| metrics_sum.audio_duration_ms = 35; |
| metrics1.media_timer_min_ms = 10; |
| metrics2.media_timer_min_ms = 25; |
| metrics_sum.media_timer_min_ms = 10; |
| metrics1.media_timer_max_ms = 100; |
| metrics2.media_timer_max_ms = 200; |
| metrics_sum.media_timer_max_ms = 200; |
| metrics1.media_timer_avg_ms = 50; |
| metrics1.total_scheduling_count = 50; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics_sum.media_timer_avg_ms = 75; |
| metrics_sum.total_scheduling_count = 100; |
| metrics1.buffer_overruns_max_count = 70; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics_sum.buffer_overruns_max_count = 80; |
| metrics1.buffer_underruns_average = 80; |
| metrics1.buffer_underruns_count = 1200; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics_sum.buffer_underruns_average = 113.33333333; |
| metrics_sum.buffer_underruns_count = 3600; |
| metrics1.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_SBC; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| metrics_sum.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_SBC; |
| DeviceInfo* info = MakeDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, |
| DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); |
| A2DPSession* session = |
| MakeA2DPSession(metrics_sum, A2dpSourceCodec::A2DP_SOURCE_CODEC_SBC); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_METRICS_DUMP, |
| info, nullptr, session)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); |
| sleep_ms(1000); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| /* |
| * Test Case: A2DPSessionDumpBeforeTwoUpdatesTest |
| * |
| * 1. Create Instance |
| * 2. LogBluetoothSessionStart |
| * 3. LogBluetoothSessionDeviceInfo |
| * 5. WriteString |
| * 6. LogA2dpSession |
| * 7. LogA2dpSession |
| * 8. LogBluetoothSessionEnd |
| * 9. WriteString |
| * |
| */ |
| TEST_F(BluetoothMetricsLoggerTest, A2DPSessionDumpBeforeTwoUpdatesTest) { |
| /* Same metrics from BluetoothA2DPSessionMetricsTest.TestUpdateNormal */ |
| A2dpSessionMetrics metrics1; |
| A2dpSessionMetrics metrics2; |
| A2dpSessionMetrics metrics_sum; |
| metrics1.audio_duration_ms = 10; |
| metrics2.audio_duration_ms = 25; |
| metrics_sum.audio_duration_ms = 35; |
| metrics1.media_timer_min_ms = 10; |
| metrics2.media_timer_min_ms = 25; |
| metrics_sum.media_timer_min_ms = 10; |
| metrics1.media_timer_max_ms = 100; |
| metrics2.media_timer_max_ms = 200; |
| metrics_sum.media_timer_max_ms = 200; |
| metrics1.media_timer_avg_ms = 50; |
| metrics1.total_scheduling_count = 50; |
| metrics2.media_timer_avg_ms = 100; |
| metrics2.total_scheduling_count = 50; |
| metrics_sum.media_timer_avg_ms = 75; |
| metrics_sum.total_scheduling_count = 100; |
| metrics1.buffer_overruns_max_count = 70; |
| metrics2.buffer_overruns_max_count = 80; |
| metrics_sum.buffer_overruns_max_count = 80; |
| metrics1.buffer_underruns_average = 80; |
| metrics1.buffer_underruns_count = 1200; |
| metrics2.buffer_underruns_average = 130; |
| metrics2.buffer_underruns_count = 2400; |
| metrics_sum.buffer_underruns_average = 113.33333333; |
| metrics_sum.buffer_underruns_count = 3600; |
| metrics1.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_SBC; |
| metrics2.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_AAC; |
| metrics_sum.codec_index = BTAV_A2DP_CODEC_INDEX_SOURCE_SBC; |
| DeviceInfo* info = MakeDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, |
| DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_METRICS_DUMP, |
| info, nullptr, nullptr)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionStart( |
| system_bt_osi::CONNECTION_TECHNOLOGY_TYPE_BREDR, 0); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, system_bt_osi::DEVICE_TYPE_BREDR); |
| sleep_ms(1000); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| ClearLog(); |
| info = MakeDeviceInfo( |
| BTM_COD_MAJOR_AUDIO_TEST, |
| DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR); |
| A2DPSession* session = |
| MakeA2DPSession(metrics_sum, A2dpSourceCodec::A2DP_SOURCE_CODEC_SBC); |
| bt_sessions_.push_back(MakeBluetoothSession( |
| 1, |
| BluetoothSession_ConnectionTechnologyType:: |
| BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR, |
| BluetoothSession_DisconnectReasonType:: |
| BluetoothSession_DisconnectReasonType_UNKNOWN, |
| info, nullptr, session)); |
| UpdateLog(); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics1); |
| BluetoothMetricsLogger::GetInstance()->LogA2dpSession(metrics2); |
| sleep_ms(1000); |
| BluetoothMetricsLogger::GetInstance()->LogBluetoothSessionEnd( |
| system_bt_osi::DISCONNECT_REASON_UNKNOWN, 0); |
| msg_str.clear(); |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| EXPECT_THAT(msg_str, StrEq(bt_log_str_)); |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, LogHeadsetProfileRfcConnectionTest) { |
| BluetoothMetricsLogger::GetInstance()->LogHeadsetProfileRfcConnection( |
| BTA_HSP_SERVICE_ID); |
| BluetoothMetricsLogger::GetInstance()->LogHeadsetProfileRfcConnection( |
| BTA_HFP_SERVICE_ID); |
| BluetoothMetricsLogger::GetInstance()->LogHeadsetProfileRfcConnection( |
| BTA_HFP_SERVICE_ID); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| BluetoothLog* metrics = BluetoothLog::default_instance().New(); |
| metrics->ParseFromString(msg_str); |
| EXPECT_EQ(metrics->headset_profile_connection_stats_size(), 2); |
| bool hfp_correct = false; |
| bool hsp_correct = false; |
| for (const HeadsetProfileConnectionStats& headset_profile_connection_stats : |
| metrics->headset_profile_connection_stats()) { |
| switch (headset_profile_connection_stats.headset_profile_type()) { |
| case HeadsetProfileType::HFP: |
| EXPECT_EQ(headset_profile_connection_stats.num_times_connected(), 2); |
| hfp_correct = true; |
| break; |
| case HeadsetProfileType::HSP: |
| EXPECT_EQ(headset_profile_connection_stats.num_times_connected(), 1); |
| hsp_correct = true; |
| break; |
| default: |
| FAIL(); |
| } |
| } |
| EXPECT_TRUE(hfp_correct); |
| EXPECT_TRUE(hsp_correct); |
| metrics->clear_headset_profile_connection_stats(); |
| EXPECT_EQ(metrics->headset_profile_connection_stats_size(), 0); |
| msg_str.clear(); |
| // Verify that dump after clean up result in an empty list |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| metrics->ParseFromString(msg_str); |
| EXPECT_EQ(metrics->headset_profile_connection_stats_size(), 0); |
| delete metrics; |
| } |
| |
| TEST_F(BluetoothMetricsLoggerTest, LogHeadsetProfileRfcConnectionErrorTest) { |
| BluetoothMetricsLogger::GetInstance()->LogHeadsetProfileRfcConnection( |
| BTA_HSP_SERVICE_ID); |
| BluetoothMetricsLogger::GetInstance()->LogHeadsetProfileRfcConnection( |
| BTA_HFP_SERVICE_ID); |
| BluetoothMetricsLogger::GetInstance()->LogHeadsetProfileRfcConnection( |
| BTA_BIP_SERVICE_ID); |
| BluetoothMetricsLogger::GetInstance()->LogHeadsetProfileRfcConnection( |
| BTA_HSP_SERVICE_ID); |
| std::string msg_str; |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| BluetoothLog* metrics = BluetoothLog::default_instance().New(); |
| metrics->ParseFromString(msg_str); |
| EXPECT_EQ(metrics->headset_profile_connection_stats_size(), 3); |
| bool hfp_correct = false; |
| bool hsp_correct = false; |
| bool unknown_correct = false; |
| for (const HeadsetProfileConnectionStats& headset_profile_connection_stats : |
| metrics->headset_profile_connection_stats()) { |
| switch (headset_profile_connection_stats.headset_profile_type()) { |
| case HeadsetProfileType::HFP: |
| EXPECT_EQ(headset_profile_connection_stats.num_times_connected(), 1); |
| hfp_correct = true; |
| break; |
| case HeadsetProfileType::HSP: |
| EXPECT_EQ(headset_profile_connection_stats.num_times_connected(), 2); |
| hsp_correct = true; |
| break; |
| default: |
| EXPECT_EQ(headset_profile_connection_stats.num_times_connected(), 1); |
| unknown_correct = true; |
| break; |
| } |
| } |
| EXPECT_TRUE(hfp_correct); |
| EXPECT_TRUE(hsp_correct); |
| EXPECT_TRUE(unknown_correct); |
| metrics->clear_headset_profile_connection_stats(); |
| EXPECT_EQ(metrics->headset_profile_connection_stats_size(), 0); |
| // Verify that dump after clean up result in an empty list |
| BluetoothMetricsLogger::GetInstance()->WriteString(&msg_str); |
| metrics->ParseFromString(msg_str); |
| EXPECT_EQ(metrics->headset_profile_connection_stats_size(), 0); |
| delete metrics; |
| } |
| } |
