bta/le_audio/client_audio_test.cc - platform/system/bt - Git at Google

 /*
  * Copyright 2021 HIMSA II K/S - www.himsa.com.
  * Represented by EHIMA - www.ehima.com
  *
  * 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 "client_audio.h"

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include <chrono>
 #include <future>

 #include "audio_hal_interface/le_audio_software.h"
 #include "base/bind_helpers.h"
 #include "common/message_loop_thread.h"
 #include "hardware/bluetooth.h"
 #include "osi/include/wakelock.h"

 using ::testing::_;
 using ::testing::Assign;
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::ReturnPointee;
 using ::testing::SaveArg;
 using std::chrono_literals::operator""ms;

 bluetooth::common::MessageLoopThread message_loop_thread("test message loop");
 bluetooth::common::MessageLoopThread* get_main_thread() {
   return &message_loop_thread;
 }
 bt_status_t do_in_main_thread(const base::Location& from_here,
                               base::OnceClosure task) {
   if (!message_loop_thread.DoInThread(from_here, std::move(task))) {
     LOG(ERROR) << __func__ << ": failed from " << from_here.ToString();
     return BT_STATUS_FAIL;
   }
   return BT_STATUS_SUCCESS;
 }

 static base::MessageLoop* message_loop_;
 base::MessageLoop* get_main_message_loop() { return message_loop_; }

 static void init_message_loop_thread() {
   message_loop_thread.StartUp();
   if (!message_loop_thread.IsRunning()) {
     FAIL() << "unable to create message loop thread.";
   }

   if (!message_loop_thread.EnableRealTimeScheduling())
     LOG(ERROR) << "Unable to set real time scheduling";

   message_loop_ = message_loop_thread.message_loop();
   if (message_loop_ == nullptr) FAIL() << "unable to get message loop.";
 }

 static void cleanup_message_loop_thread() {
   message_loop_ = nullptr;
   message_loop_thread.ShutDown();
 }

 using bluetooth::audio::le_audio::LeAudioClientInterface;

 class MockLeAudioClientInterfaceSink : public LeAudioClientInterface::Sink {
  public:
   MOCK_METHOD((void), Cleanup, (), (override));
   MOCK_METHOD((void), SetPcmParameters,
               (const LeAudioClientInterface::PcmParameters& params),
               (override));
   MOCK_METHOD((void), SetRemoteDelay, (uint16_t delay_report_ms), (override));
   MOCK_METHOD((void), StartSession, (), (override));
   MOCK_METHOD((void), StopSession, (), (override));
   MOCK_METHOD((void), ConfirmStreamingRequest, (), (override));
   MOCK_METHOD((void), CancelStreamingRequest, (), (override));
   MOCK_METHOD((size_t), Read, (uint8_t * p_buf, uint32_t len));
 };

 class MockLeAudioClientInterfaceSource : public LeAudioClientInterface::Source {
  public:
   MOCK_METHOD((void), Cleanup, (), (override));
   MOCK_METHOD((void), SetPcmParameters,
               (const LeAudioClientInterface::PcmParameters& params),
               (override));
   MOCK_METHOD((void), SetRemoteDelay, (uint16_t delay_report_ms), (override));
   MOCK_METHOD((void), StartSession, (), (override));
   MOCK_METHOD((void), StopSession, (), (override));
   MOCK_METHOD((void), ConfirmStreamingRequest, (), (override));
   MOCK_METHOD((void), CancelStreamingRequest, (), (override));
   MOCK_METHOD((size_t), Write, (const uint8_t* p_buf, uint32_t len));
 };

 class MockLeAudioClientInterface : public LeAudioClientInterface {
  public:
   MockLeAudioClientInterface() = default;
   ~MockLeAudioClientInterface() = default;

   MOCK_METHOD((Sink*), GetSink,
               (bluetooth::audio::le_audio::StreamCallbacks stream_cb,
                bluetooth::common::MessageLoopThread* message_loop));
   MOCK_METHOD((Source*), GetSource,
               (bluetooth::audio::le_audio::StreamCallbacks stream_cb,
                bluetooth::common::MessageLoopThread* message_loop));
 };

 LeAudioClientInterface* mockInterface;

 namespace bluetooth {
 namespace audio {
 namespace le_audio {
 MockLeAudioClientInterface* interface_mock;
 MockLeAudioClientInterfaceSink* sink_mock;
 MockLeAudioClientInterfaceSource* source_mock;

 LeAudioClientInterface* LeAudioClientInterface::Get() { return interface_mock; }

 LeAudioClientInterface::Sink* LeAudioClientInterface::GetSink(
     StreamCallbacks stream_cb,
     bluetooth::common::MessageLoopThread* message_loop) {
   return interface_mock->GetSink(stream_cb, message_loop);
 }

 LeAudioClientInterface::Source* LeAudioClientInterface::GetSource(
     StreamCallbacks stream_cb,
     bluetooth::common::MessageLoopThread* message_loop) {
   return interface_mock->GetSource(stream_cb, message_loop);
 }

 bool LeAudioClientInterface::ReleaseSink(LeAudioClientInterface::Sink* sink) {
   return true;
 }
 bool LeAudioClientInterface::ReleaseSource(
     LeAudioClientInterface::Source* source) {
   return true;
 }

 void LeAudioClientInterface::Sink::Cleanup() {}
 void LeAudioClientInterface::Sink::SetPcmParameters(
     const PcmParameters& params) {}
 void LeAudioClientInterface::Sink::SetRemoteDelay(uint16_t delay_report_ms) {}
 void LeAudioClientInterface::Sink::StartSession() {}
 void LeAudioClientInterface::Sink::StopSession() {}
 void LeAudioClientInterface::Sink::ConfirmStreamingRequest(){};
 void LeAudioClientInterface::Sink::CancelStreamingRequest(){};

 void LeAudioClientInterface::Source::Cleanup() {}
 void LeAudioClientInterface::Source::SetPcmParameters(
     const PcmParameters& params) {}
 void LeAudioClientInterface::Source::SetRemoteDelay(uint16_t delay_report_ms) {}
 void LeAudioClientInterface::Source::StartSession() {}
 void LeAudioClientInterface::Source::StopSession() {}
 void LeAudioClientInterface::Source::ConfirmStreamingRequest(){};
 void LeAudioClientInterface::Source::CancelStreamingRequest(){};

 size_t LeAudioClientInterface::Source::Write(const uint8_t* p_buf,
                                              uint32_t len) {
   return source_mock->Write(p_buf, len);
 }

 size_t LeAudioClientInterface::Sink::Read(uint8_t* p_buf, uint32_t len) {
   return sink_mock->Read(p_buf, len);
 }
 }  // namespace le_audio
 }  // namespace audio
 }  // namespace bluetooth

 class MockLeAudioClientAudioSinkEventReceiver
     : public LeAudioClientAudioSinkReceiver {
  public:
   MOCK_METHOD((void), OnAudioDataReady, (const std::vector<uint8_t>& data),
               (override));
   MOCK_METHOD((void), OnAudioSuspend, (std::promise<void> do_suspend_promise),
               (override));
   MOCK_METHOD((void), OnAudioResume, (std::promise<void> do_resume_promise),
               (override));
   MOCK_METHOD((void), OnAudioMetadataUpdate,
               (std::promise<void> do_update_metadata_promise,
                const source_metadata_t& source_metadata),
               (override));
 };

 class MockLeAudioClientAudioSourceEventReceiver
     : public LeAudioClientAudioSourceReceiver {
  public:
   MOCK_METHOD((void), OnAudioSuspend, (std::promise<void> do_suspend_promise),
               (override));
   MOCK_METHOD((void), OnAudioResume, (std::promise<void> do_resume_promise),
               (override));
 };

 class LeAudioClientAudioTest : public ::testing::Test {
  public:
   void SetUp(void) override {
     init_message_loop_thread();
     bluetooth::audio::le_audio::interface_mock = &mock_client_interface_;
     bluetooth::audio::le_audio::sink_mock = &mock_client_interface_sink_;
     bluetooth::audio::le_audio::source_mock = &mock_client_interface_source_;

     // Init sink Audio HAL mock
     is_sink_acquired = false;
     hal_sink_stream_cb = {.on_suspend_ = nullptr, .on_resume_ = nullptr};

     ON_CALL(mock_client_interface_, GetSink(_, _))
         .WillByDefault(DoAll(SaveArg<0>(&hal_sink_stream_cb),
                              Assign(&is_sink_acquired, true),
                              Return(bluetooth::audio::le_audio::sink_mock)));
     ON_CALL(mock_client_interface_sink_, Cleanup())
         .WillByDefault(Assign(&is_sink_acquired, false));

     // Init source Audio HAL mock
     is_source_acquired = false;
     hal_source_stream_cb = {.on_suspend_ = nullptr, .on_resume_ = nullptr};

     ON_CALL(mock_client_interface_, GetSource(_, _))
         .WillByDefault(DoAll(SaveArg<0>(&hal_source_stream_cb),
                              Assign(&is_source_acquired, true),
                              Return(bluetooth::audio::le_audio::source_mock)));
     ON_CALL(mock_client_interface_source_, Cleanup())
         .WillByDefault(Assign(&is_source_acquired, false));
   }

   void AcquireAudioSink(void) {
     audio_sink_instance_ = LeAudioClientAudioSink::Acquire();
   }

   void ReleaseAudioSink(void) {
     LeAudioClientAudioSink::Release(audio_sink_instance_);
     audio_sink_instance_ = nullptr;
   }

   void AcquireAudioSource(void) {
     audio_source_instance_ = LeAudioClientAudioSource::Acquire();
   }

   void ReleaseAudioSource(void) {
     LeAudioClientAudioSource::Release(audio_source_instance_);
     audio_source_instance_ = nullptr;
   }

   void TearDown(void) override {
     /* We have to call Cleanup to tidy up some static variables.
      * If on the HAL end Source is running it means we are running the Sink
      * on our end, and vice versa.
      */
     if (is_source_acquired == true) ReleaseAudioSink();
     if (is_sink_acquired == true) ReleaseAudioSource();

     cleanup_message_loop_thread();

     bluetooth::audio::le_audio::sink_mock = nullptr;
     bluetooth::audio::le_audio::source_mock = nullptr;
   }

   MockLeAudioClientInterface mock_client_interface_;
   MockLeAudioClientInterfaceSink mock_client_interface_sink_;
   MockLeAudioClientInterfaceSource mock_client_interface_source_;

   MockLeAudioClientAudioSinkEventReceiver mock_hal_sink_event_receiver_;
   MockLeAudioClientAudioSourceEventReceiver mock_hal_source_event_receiver_;

   bool is_source_acquired = false;
   bool is_sink_acquired = false;
   const void* audio_sink_instance_ = nullptr;
   const void* audio_source_instance_ = nullptr;

   bluetooth::audio::le_audio::StreamCallbacks hal_source_stream_cb;
   bluetooth::audio::le_audio::StreamCallbacks hal_sink_stream_cb;

   const LeAudioCodecConfiguration default_codec_conf{
       .num_channels = LeAudioCodecConfiguration::kChannelNumberMono,
       .sample_rate = LeAudioCodecConfiguration::kSampleRate44100,
       .bits_per_sample = LeAudioCodecConfiguration::kBitsPerSample24,
       .data_interval_us = LeAudioCodecConfiguration::kInterval10000Us,
   };
 };

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkInitializeCleanup) {
   EXPECT_CALL(mock_client_interface_, GetSource(_, _))
       .WillOnce(DoAll(Assign(&is_source_acquired, true),
                       Return(bluetooth::audio::le_audio::source_mock)));
   AcquireAudioSink();

   EXPECT_CALL(mock_client_interface_source_, Cleanup())
       .WillOnce(Assign(&is_source_acquired, false));
   ReleaseAudioSink();
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceInitializeCleanup) {
   EXPECT_CALL(mock_client_interface_, GetSink(_, _))
       .WillOnce(DoAll(Assign(&is_sink_acquired, true),
                       Return(bluetooth::audio::le_audio::sink_mock)));
   AcquireAudioSource();

   EXPECT_CALL(mock_client_interface_sink_, Cleanup())
       .WillOnce(Assign(&is_sink_acquired, false));
   ReleaseAudioSource();
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkStartStop) {
   LeAudioClientInterface::PcmParameters params;
   EXPECT_CALL(mock_client_interface_source_, SetPcmParameters(_))
       .Times(1)
       .WillOnce(SaveArg<0>(&params));
   EXPECT_CALL(mock_client_interface_source_, StartSession()).Times(1);

   AcquireAudioSink();
   ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
                                             &mock_hal_source_event_receiver_));

   ASSERT_EQ(params.channels_count,
             bluetooth::audio::le_audio::kChannelNumberMono);
   ASSERT_EQ(params.sample_rate, bluetooth::audio::le_audio::kSampleRate44100);
   ASSERT_EQ(params.bits_per_sample,
             bluetooth::audio::le_audio::kBitsPerSample24);
   ASSERT_EQ(params.data_interval_us, 10000u);

   EXPECT_CALL(mock_client_interface_source_, StopSession()).Times(1);

   LeAudioClientAudioSink::Stop();
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceStartStop) {
   LeAudioClientInterface::PcmParameters params;
   EXPECT_CALL(mock_client_interface_sink_, SetPcmParameters(_))
       .Times(1)
       .WillOnce(SaveArg<0>(&params));
   EXPECT_CALL(mock_client_interface_sink_, StartSession()).Times(1);

   AcquireAudioSource();
   ASSERT_TRUE(LeAudioClientAudioSource::Start(default_codec_conf,
                                               &mock_hal_sink_event_receiver_));

   ASSERT_EQ(params.channels_count,
             bluetooth::audio::le_audio::kChannelNumberMono);
   ASSERT_EQ(params.sample_rate, bluetooth::audio::le_audio::kSampleRate44100);
   ASSERT_EQ(params.bits_per_sample,
             bluetooth::audio::le_audio::kBitsPerSample24);
   ASSERT_EQ(params.data_interval_us, 10000u);

   EXPECT_CALL(mock_client_interface_sink_, StopSession()).Times(1);

   LeAudioClientAudioSource::Stop();
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkSendData) {
   AcquireAudioSink();
   ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
                                             &mock_hal_source_event_receiver_));

   const uint8_t* exp_p = nullptr;
   uint32_t exp_len = 0;
   uint8_t input_buf[] = {
       0x02,
       0x03,
       0x05,
       0x19,
   };
   ON_CALL(mock_client_interface_source_, Write(_, _))
       .WillByDefault(DoAll(SaveArg<0>(&exp_p), SaveArg<1>(&exp_len),
                            ReturnPointee(&exp_len)));

   ASSERT_EQ(LeAudioClientAudioSink::SendData(input_buf, sizeof(input_buf)),
             sizeof(input_buf));
   ASSERT_EQ(exp_len, sizeof(input_buf));
   ASSERT_EQ(exp_p, input_buf);

   LeAudioClientAudioSource::Stop();
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkSuspend) {
   AcquireAudioSink();
   ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
                                             &mock_hal_source_event_receiver_));

   ASSERT_NE(hal_source_stream_cb.on_suspend_, nullptr);

   /* Expect LeAudio registered event listener to get called when HAL calls the
    * client_audio's internal suspend callback.
    */
   EXPECT_CALL(mock_hal_source_event_receiver_, OnAudioSuspend(_)).Times(1);
   ASSERT_TRUE(hal_source_stream_cb.on_suspend_());
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceSuspend) {
   AcquireAudioSource();
   ASSERT_TRUE(LeAudioClientAudioSource::Start(default_codec_conf,
                                               &mock_hal_sink_event_receiver_));

   ASSERT_NE(hal_sink_stream_cb.on_suspend_, nullptr);

   /* Expect LeAudio registered event listener to get called when HAL calls the
    * client_audio's internal suspend callback.
    */
   EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioSuspend(_)).Times(1);
   ASSERT_TRUE(hal_sink_stream_cb.on_suspend_());
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkResume) {
   AcquireAudioSink();
   ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
                                             &mock_hal_source_event_receiver_));

   ASSERT_NE(hal_source_stream_cb.on_resume_, nullptr);

   /* Expect LeAudio registered event listener to get called when HAL calls the
    * client_audio's internal resume callback.
    */
   EXPECT_CALL(mock_hal_source_event_receiver_, OnAudioResume(_)).Times(1);
   bool start_media_task = false;
   ASSERT_TRUE(hal_source_stream_cb.on_resume_(start_media_task));
 }

 TEST_F(LeAudioClientAudioTest,
        testLeAudioClientAudioSourceResumeStartSourceTask) {
   const LeAudioCodecConfiguration codec_conf{
       .num_channels = LeAudioCodecConfiguration::kChannelNumberStereo,
       .sample_rate = LeAudioCodecConfiguration::kSampleRate16000,
       .bits_per_sample = LeAudioCodecConfiguration::kBitsPerSample24,
       .data_interval_us = LeAudioCodecConfiguration::kInterval10000Us,
   };
   AcquireAudioSource();
   ASSERT_TRUE(LeAudioClientAudioSource::Start(codec_conf,
                                               &mock_hal_sink_event_receiver_));

   std::chrono::time_point<std::chrono::system_clock> resumed_ts;
   std::chrono::time_point<std::chrono::system_clock> executed_ts;
   std::promise<void> promise;
   auto future = promise.get_future();

   uint32_t calculated_bytes_per_tick = 0;
   EXPECT_CALL(mock_client_interface_sink_, Read(_, _))
       .Times(AtLeast(1))
       .WillOnce(Invoke([&](uint8_t* p_buf, uint32_t len) -> uint32_t {
         executed_ts = std::chrono::system_clock::now();
         calculated_bytes_per_tick = len;

         // fake some data from audio framework
         for (uint32_t i = 0u; i < len; ++i) {
           p_buf[i] = i;
         }

         // Return exactly as much data as requested
         promise.set_value();
         return len;
       }));

   std::promise<void> data_promise;
   auto data_future = data_promise.get_future();

   /* Expect this callback to be called to Client by the HAL glue layer */
   std::vector<uint8_t> media_data_to_send;
   EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioDataReady(_))
       .WillOnce(Invoke([&](const std::vector<uint8_t>& data) -> void {
         media_data_to_send = std::move(data);
         data_promise.set_value();
       }));

   /* Expect LeAudio registered event listener to get called when HAL calls the
    * client_audio's internal resume callback.
    */
   ASSERT_NE(hal_sink_stream_cb.on_resume_, nullptr);
   EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioResume(_)).Times(1);
   resumed_ts = std::chrono::system_clock::now();
   bool start_media_task = true;
   ASSERT_TRUE(hal_sink_stream_cb.on_resume_(start_media_task));
   LeAudioClientAudioSource::ConfirmStreamingRequest();

   ASSERT_EQ(future.wait_for(std::chrono::seconds(1)),
             std::future_status::ready);

   ASSERT_EQ(data_future.wait_for(std::chrono::seconds(1)),
             std::future_status::ready);

   // Check agains expected payload size
   const uint32_t channel_bytes_per_sample = (24 /*bps*/ / 8);
   const uint32_t channel_bytes_per_10ms_at_16000Hz =
       ((10ms).count() * channel_bytes_per_sample * 16000 /*Hz*/) /
       (1000ms).count();

   // Expect 2 channel (stereo) data
   ASSERT_EQ(calculated_bytes_per_tick, 2 * channel_bytes_per_10ms_at_16000Hz);

   // Verify callback call interval for the requested 10ms (+2ms error margin)
   auto delta = std::chrono::duration_cast<std::chrono::milliseconds>(
       executed_ts - resumed_ts);
   EXPECT_TRUE((delta >= 10ms) && (delta <= 12ms));

   // Verify if we got just right amount of data in the callback call
   ASSERT_EQ(media_data_to_send.size(), calculated_bytes_per_tick);
 }

 TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceResume) {
   AcquireAudioSource();
   ASSERT_TRUE(LeAudioClientAudioSource::Start(default_codec_conf,
                                               &mock_hal_sink_event_receiver_));

   ASSERT_NE(hal_sink_stream_cb.on_resume_, nullptr);

   /* Expect LeAudio registered event listener to get called when HAL calls the
    * client_audio's internal resume callback.
    */
   EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioResume(_)).Times(1);
   bool start_media_task = false;
   ASSERT_TRUE(hal_sink_stream_cb.on_resume_(start_media_task));
 }
	/*
	* Copyright 2021 HIMSA II K/S - www.himsa.com.
	* Represented by EHIMA - www.ehima.com
	*
	* 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 "client_audio.h"

	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include <chrono>
	#include <future>

	#include "audio_hal_interface/le_audio_software.h"
	#include "base/bind_helpers.h"
	#include "common/message_loop_thread.h"
	#include "hardware/bluetooth.h"
	#include "osi/include/wakelock.h"

	using ::testing::_;
	using ::testing::Assign;
	using ::testing::AtLeast;
	using ::testing::DoAll;
	using ::testing::Invoke;
	using ::testing::Mock;
	using ::testing::Return;
	using ::testing::ReturnPointee;
	using ::testing::SaveArg;
	using std::chrono_literals::operator""ms;

	bluetooth::common::MessageLoopThread message_loop_thread("test message loop");
	bluetooth::common::MessageLoopThread* get_main_thread() {
	return &message_loop_thread;
	}
	bt_status_t do_in_main_thread(const base::Location& from_here,
	base::OnceClosure task) {
	if (!message_loop_thread.DoInThread(from_here, std::move(task))) {
	LOG(ERROR) << __func__ << ": failed from " << from_here.ToString();
	return BT_STATUS_FAIL;
	}
	return BT_STATUS_SUCCESS;
	}

	static base::MessageLoop* message_loop_;
	base::MessageLoop* get_main_message_loop() { return message_loop_; }

	static void init_message_loop_thread() {
	message_loop_thread.StartUp();
	if (!message_loop_thread.IsRunning()) {
	FAIL() << "unable to create message loop thread.";
	}

	if (!message_loop_thread.EnableRealTimeScheduling())
	LOG(ERROR) << "Unable to set real time scheduling";

	message_loop_ = message_loop_thread.message_loop();
	if (message_loop_ == nullptr) FAIL() << "unable to get message loop.";
	}

	static void cleanup_message_loop_thread() {
	message_loop_ = nullptr;
	message_loop_thread.ShutDown();
	}

	using bluetooth::audio::le_audio::LeAudioClientInterface;

	class MockLeAudioClientInterfaceSink : public LeAudioClientInterface::Sink {
	public:
	MOCK_METHOD((void), Cleanup, (), (override));
	MOCK_METHOD((void), SetPcmParameters,
	(const LeAudioClientInterface::PcmParameters& params),
	(override));
	MOCK_METHOD((void), SetRemoteDelay, (uint16_t delay_report_ms), (override));
	MOCK_METHOD((void), StartSession, (), (override));
	MOCK_METHOD((void), StopSession, (), (override));
	MOCK_METHOD((void), ConfirmStreamingRequest, (), (override));
	MOCK_METHOD((void), CancelStreamingRequest, (), (override));
	MOCK_METHOD((size_t), Read, (uint8_t * p_buf, uint32_t len));
	};

	class MockLeAudioClientInterfaceSource : public LeAudioClientInterface::Source {
	public:
	MOCK_METHOD((void), Cleanup, (), (override));
	MOCK_METHOD((void), SetPcmParameters,
	(const LeAudioClientInterface::PcmParameters& params),
	(override));
	MOCK_METHOD((void), SetRemoteDelay, (uint16_t delay_report_ms), (override));
	MOCK_METHOD((void), StartSession, (), (override));
	MOCK_METHOD((void), StopSession, (), (override));
	MOCK_METHOD((void), ConfirmStreamingRequest, (), (override));
	MOCK_METHOD((void), CancelStreamingRequest, (), (override));
	MOCK_METHOD((size_t), Write, (const uint8_t* p_buf, uint32_t len));
	};

	class MockLeAudioClientInterface : public LeAudioClientInterface {
	public:
	MockLeAudioClientInterface() = default;
	~MockLeAudioClientInterface() = default;

	MOCK_METHOD((Sink*), GetSink,
	(bluetooth::audio::le_audio::StreamCallbacks stream_cb,
	bluetooth::common::MessageLoopThread* message_loop));
	MOCK_METHOD((Source*), GetSource,
	(bluetooth::audio::le_audio::StreamCallbacks stream_cb,
	bluetooth::common::MessageLoopThread* message_loop));
	};

	LeAudioClientInterface* mockInterface;

	namespace bluetooth {
	namespace audio {
	namespace le_audio {
	MockLeAudioClientInterface* interface_mock;
	MockLeAudioClientInterfaceSink* sink_mock;
	MockLeAudioClientInterfaceSource* source_mock;

	LeAudioClientInterface* LeAudioClientInterface::Get() { return interface_mock; }

	LeAudioClientInterface::Sink* LeAudioClientInterface::GetSink(
	StreamCallbacks stream_cb,
	bluetooth::common::MessageLoopThread* message_loop) {
	return interface_mock->GetSink(stream_cb, message_loop);
	}

	LeAudioClientInterface::Source* LeAudioClientInterface::GetSource(
	StreamCallbacks stream_cb,
	bluetooth::common::MessageLoopThread* message_loop) {
	return interface_mock->GetSource(stream_cb, message_loop);
	}

	bool LeAudioClientInterface::ReleaseSink(LeAudioClientInterface::Sink* sink) {
	return true;
	}
	bool LeAudioClientInterface::ReleaseSource(
	LeAudioClientInterface::Source* source) {
	return true;
	}

	void LeAudioClientInterface::Sink::Cleanup() {}
	void LeAudioClientInterface::Sink::SetPcmParameters(
	const PcmParameters& params) {}
	void LeAudioClientInterface::Sink::SetRemoteDelay(uint16_t delay_report_ms) {}
	void LeAudioClientInterface::Sink::StartSession() {}
	void LeAudioClientInterface::Sink::StopSession() {}
	void LeAudioClientInterface::Sink::ConfirmStreamingRequest(){};
	void LeAudioClientInterface::Sink::CancelStreamingRequest(){};

	void LeAudioClientInterface::Source::Cleanup() {}
	void LeAudioClientInterface::Source::SetPcmParameters(
	const PcmParameters& params) {}
	void LeAudioClientInterface::Source::SetRemoteDelay(uint16_t delay_report_ms) {}
	void LeAudioClientInterface::Source::StartSession() {}
	void LeAudioClientInterface::Source::StopSession() {}
	void LeAudioClientInterface::Source::ConfirmStreamingRequest(){};
	void LeAudioClientInterface::Source::CancelStreamingRequest(){};

	size_t LeAudioClientInterface::Source::Write(const uint8_t* p_buf,
	uint32_t len) {
	return source_mock->Write(p_buf, len);
	}

	size_t LeAudioClientInterface::Sink::Read(uint8_t* p_buf, uint32_t len) {
	return sink_mock->Read(p_buf, len);
	}
	} // namespace le_audio
	} // namespace audio
	} // namespace bluetooth

	class MockLeAudioClientAudioSinkEventReceiver
	: public LeAudioClientAudioSinkReceiver {
	public:
	MOCK_METHOD((void), OnAudioDataReady, (const std::vector<uint8_t>& data),
	(override));
	MOCK_METHOD((void), OnAudioSuspend, (std::promise<void> do_suspend_promise),
	(override));
	MOCK_METHOD((void), OnAudioResume, (std::promise<void> do_resume_promise),
	(override));
	MOCK_METHOD((void), OnAudioMetadataUpdate,
	(std::promise<void> do_update_metadata_promise,
	const source_metadata_t& source_metadata),
	(override));
	};

	class MockLeAudioClientAudioSourceEventReceiver
	: public LeAudioClientAudioSourceReceiver {
	public:
	MOCK_METHOD((void), OnAudioSuspend, (std::promise<void> do_suspend_promise),
	(override));
	MOCK_METHOD((void), OnAudioResume, (std::promise<void> do_resume_promise),
	(override));
	};

	class LeAudioClientAudioTest : public ::testing::Test {
	public:
	void SetUp(void) override {
	init_message_loop_thread();
	bluetooth::audio::le_audio::interface_mock = &mock_client_interface_;
	bluetooth::audio::le_audio::sink_mock = &mock_client_interface_sink_;
	bluetooth::audio::le_audio::source_mock = &mock_client_interface_source_;

	// Init sink Audio HAL mock
	is_sink_acquired = false;
	hal_sink_stream_cb = {.on_suspend_ = nullptr, .on_resume_ = nullptr};

	ON_CALL(mock_client_interface_, GetSink(_, _))
	.WillByDefault(DoAll(SaveArg<0>(&hal_sink_stream_cb),
	Assign(&is_sink_acquired, true),
	Return(bluetooth::audio::le_audio::sink_mock)));
	ON_CALL(mock_client_interface_sink_, Cleanup())
	.WillByDefault(Assign(&is_sink_acquired, false));

	// Init source Audio HAL mock
	is_source_acquired = false;
	hal_source_stream_cb = {.on_suspend_ = nullptr, .on_resume_ = nullptr};

	ON_CALL(mock_client_interface_, GetSource(_, _))
	.WillByDefault(DoAll(SaveArg<0>(&hal_source_stream_cb),
	Assign(&is_source_acquired, true),
	Return(bluetooth::audio::le_audio::source_mock)));
	ON_CALL(mock_client_interface_source_, Cleanup())
	.WillByDefault(Assign(&is_source_acquired, false));
	}

	void AcquireAudioSink(void) {
	audio_sink_instance_ = LeAudioClientAudioSink::Acquire();
	}

	void ReleaseAudioSink(void) {
	LeAudioClientAudioSink::Release(audio_sink_instance_);
	audio_sink_instance_ = nullptr;
	}

	void AcquireAudioSource(void) {
	audio_source_instance_ = LeAudioClientAudioSource::Acquire();
	}

	void ReleaseAudioSource(void) {
	LeAudioClientAudioSource::Release(audio_source_instance_);
	audio_source_instance_ = nullptr;
	}

	void TearDown(void) override {
	/* We have to call Cleanup to tidy up some static variables.
	* If on the HAL end Source is running it means we are running the Sink
	* on our end, and vice versa.
	*/
	if (is_source_acquired == true) ReleaseAudioSink();
	if (is_sink_acquired == true) ReleaseAudioSource();

	cleanup_message_loop_thread();

	bluetooth::audio::le_audio::sink_mock = nullptr;
	bluetooth::audio::le_audio::source_mock = nullptr;
	}

	MockLeAudioClientInterface mock_client_interface_;
	MockLeAudioClientInterfaceSink mock_client_interface_sink_;
	MockLeAudioClientInterfaceSource mock_client_interface_source_;

	MockLeAudioClientAudioSinkEventReceiver mock_hal_sink_event_receiver_;
	MockLeAudioClientAudioSourceEventReceiver mock_hal_source_event_receiver_;

	bool is_source_acquired = false;
	bool is_sink_acquired = false;
	const void* audio_sink_instance_ = nullptr;
	const void* audio_source_instance_ = nullptr;

	bluetooth::audio::le_audio::StreamCallbacks hal_source_stream_cb;
	bluetooth::audio::le_audio::StreamCallbacks hal_sink_stream_cb;

	const LeAudioCodecConfiguration default_codec_conf{
	.num_channels = LeAudioCodecConfiguration::kChannelNumberMono,
	.sample_rate = LeAudioCodecConfiguration::kSampleRate44100,
	.bits_per_sample = LeAudioCodecConfiguration::kBitsPerSample24,
	.data_interval_us = LeAudioCodecConfiguration::kInterval10000Us,
	};
	};

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkInitializeCleanup) {
	EXPECT_CALL(mock_client_interface_, GetSource(_, _))
	.WillOnce(DoAll(Assign(&is_source_acquired, true),
	Return(bluetooth::audio::le_audio::source_mock)));
	AcquireAudioSink();

	EXPECT_CALL(mock_client_interface_source_, Cleanup())
	.WillOnce(Assign(&is_source_acquired, false));
	ReleaseAudioSink();
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceInitializeCleanup) {
	EXPECT_CALL(mock_client_interface_, GetSink(_, _))
	.WillOnce(DoAll(Assign(&is_sink_acquired, true),
	Return(bluetooth::audio::le_audio::sink_mock)));
	AcquireAudioSource();

	EXPECT_CALL(mock_client_interface_sink_, Cleanup())
	.WillOnce(Assign(&is_sink_acquired, false));
	ReleaseAudioSource();
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkStartStop) {
	LeAudioClientInterface::PcmParameters params;
	EXPECT_CALL(mock_client_interface_source_, SetPcmParameters(_))
	.Times(1)
	.WillOnce(SaveArg<0>(&params));
	EXPECT_CALL(mock_client_interface_source_, StartSession()).Times(1);

	AcquireAudioSink();
	ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
	&mock_hal_source_event_receiver_));

	ASSERT_EQ(params.channels_count,
	bluetooth::audio::le_audio::kChannelNumberMono);
	ASSERT_EQ(params.sample_rate, bluetooth::audio::le_audio::kSampleRate44100);
	ASSERT_EQ(params.bits_per_sample,
	bluetooth::audio::le_audio::kBitsPerSample24);
	ASSERT_EQ(params.data_interval_us, 10000u);

	EXPECT_CALL(mock_client_interface_source_, StopSession()).Times(1);

	LeAudioClientAudioSink::Stop();
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceStartStop) {
	LeAudioClientInterface::PcmParameters params;
	EXPECT_CALL(mock_client_interface_sink_, SetPcmParameters(_))
	.Times(1)
	.WillOnce(SaveArg<0>(&params));
	EXPECT_CALL(mock_client_interface_sink_, StartSession()).Times(1);

	AcquireAudioSource();
	ASSERT_TRUE(LeAudioClientAudioSource::Start(default_codec_conf,
	&mock_hal_sink_event_receiver_));

	ASSERT_EQ(params.channels_count,
	bluetooth::audio::le_audio::kChannelNumberMono);
	ASSERT_EQ(params.sample_rate, bluetooth::audio::le_audio::kSampleRate44100);
	ASSERT_EQ(params.bits_per_sample,
	bluetooth::audio::le_audio::kBitsPerSample24);
	ASSERT_EQ(params.data_interval_us, 10000u);

	EXPECT_CALL(mock_client_interface_sink_, StopSession()).Times(1);

	LeAudioClientAudioSource::Stop();
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkSendData) {
	AcquireAudioSink();
	ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
	&mock_hal_source_event_receiver_));

	const uint8_t* exp_p = nullptr;
	uint32_t exp_len = 0;
	uint8_t input_buf[] = {
	0x02,
	0x03,
	0x05,
	0x19,
	};
	ON_CALL(mock_client_interface_source_, Write(_, _))
	.WillByDefault(DoAll(SaveArg<0>(&exp_p), SaveArg<1>(&exp_len),
	ReturnPointee(&exp_len)));

	ASSERT_EQ(LeAudioClientAudioSink::SendData(input_buf, sizeof(input_buf)),
	sizeof(input_buf));
	ASSERT_EQ(exp_len, sizeof(input_buf));
	ASSERT_EQ(exp_p, input_buf);

	LeAudioClientAudioSource::Stop();
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkSuspend) {
	AcquireAudioSink();
	ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
	&mock_hal_source_event_receiver_));

	ASSERT_NE(hal_source_stream_cb.on_suspend_, nullptr);

	/* Expect LeAudio registered event listener to get called when HAL calls the
	* client_audio's internal suspend callback.
	*/
	EXPECT_CALL(mock_hal_source_event_receiver_, OnAudioSuspend(_)).Times(1);
	ASSERT_TRUE(hal_source_stream_cb.on_suspend_());
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceSuspend) {
	AcquireAudioSource();
	ASSERT_TRUE(LeAudioClientAudioSource::Start(default_codec_conf,
	&mock_hal_sink_event_receiver_));

	ASSERT_NE(hal_sink_stream_cb.on_suspend_, nullptr);

	/* Expect LeAudio registered event listener to get called when HAL calls the
	* client_audio's internal suspend callback.
	*/
	EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioSuspend(_)).Times(1);
	ASSERT_TRUE(hal_sink_stream_cb.on_suspend_());
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSinkResume) {
	AcquireAudioSink();
	ASSERT_TRUE(LeAudioClientAudioSink::Start(default_codec_conf,
	&mock_hal_source_event_receiver_));

	ASSERT_NE(hal_source_stream_cb.on_resume_, nullptr);

	/* Expect LeAudio registered event listener to get called when HAL calls the
	* client_audio's internal resume callback.
	*/
	EXPECT_CALL(mock_hal_source_event_receiver_, OnAudioResume(_)).Times(1);
	bool start_media_task = false;
	ASSERT_TRUE(hal_source_stream_cb.on_resume_(start_media_task));
	}

	TEST_F(LeAudioClientAudioTest,
	testLeAudioClientAudioSourceResumeStartSourceTask) {
	const LeAudioCodecConfiguration codec_conf{
	.num_channels = LeAudioCodecConfiguration::kChannelNumberStereo,
	.sample_rate = LeAudioCodecConfiguration::kSampleRate16000,
	.bits_per_sample = LeAudioCodecConfiguration::kBitsPerSample24,
	.data_interval_us = LeAudioCodecConfiguration::kInterval10000Us,
	};
	AcquireAudioSource();
	ASSERT_TRUE(LeAudioClientAudioSource::Start(codec_conf,
	&mock_hal_sink_event_receiver_));

	std::chrono::time_point<std::chrono::system_clock> resumed_ts;
	std::chrono::time_point<std::chrono::system_clock> executed_ts;
	std::promise<void> promise;
	auto future = promise.get_future();

	uint32_t calculated_bytes_per_tick = 0;
	EXPECT_CALL(mock_client_interface_sink_, Read(_, _))
	.Times(AtLeast(1))
	.WillOnce(Invoke([&](uint8_t* p_buf, uint32_t len) -> uint32_t {
	executed_ts = std::chrono::system_clock::now();
	calculated_bytes_per_tick = len;

	// fake some data from audio framework
	for (uint32_t i = 0u; i < len; ++i) {
	p_buf[i] = i;
	}

	// Return exactly as much data as requested
	promise.set_value();
	return len;
	}));

	std::promise<void> data_promise;
	auto data_future = data_promise.get_future();

	/* Expect this callback to be called to Client by the HAL glue layer */
	std::vector<uint8_t> media_data_to_send;
	EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioDataReady(_))
	.WillOnce(Invoke([&](const std::vector<uint8_t>& data) -> void {
	media_data_to_send = std::move(data);
	data_promise.set_value();
	}));

	/* Expect LeAudio registered event listener to get called when HAL calls the
	* client_audio's internal resume callback.
	*/
	ASSERT_NE(hal_sink_stream_cb.on_resume_, nullptr);
	EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioResume(_)).Times(1);
	resumed_ts = std::chrono::system_clock::now();
	bool start_media_task = true;
	ASSERT_TRUE(hal_sink_stream_cb.on_resume_(start_media_task));
	LeAudioClientAudioSource::ConfirmStreamingRequest();

	ASSERT_EQ(future.wait_for(std::chrono::seconds(1)),
	std::future_status::ready);

	ASSERT_EQ(data_future.wait_for(std::chrono::seconds(1)),
	std::future_status::ready);

	// Check agains expected payload size
	const uint32_t channel_bytes_per_sample = (24 /bps/ / 8);
	const uint32_t channel_bytes_per_10ms_at_16000Hz =
	((10ms).count() * channel_bytes_per_sample * 16000 /Hz/) /
	(1000ms).count();

	// Expect 2 channel (stereo) data
	ASSERT_EQ(calculated_bytes_per_tick, 2 * channel_bytes_per_10ms_at_16000Hz);

	// Verify callback call interval for the requested 10ms (+2ms error margin)
	auto delta = std::chrono::duration_cast<std::chrono::milliseconds>(
	executed_ts - resumed_ts);
	EXPECT_TRUE((delta >= 10ms) && (delta <= 12ms));

	// Verify if we got just right amount of data in the callback call
	ASSERT_EQ(media_data_to_send.size(), calculated_bytes_per_tick);
	}

	TEST_F(LeAudioClientAudioTest, testLeAudioClientAudioSourceResume) {
	AcquireAudioSource();
	ASSERT_TRUE(LeAudioClientAudioSource::Start(default_codec_conf,
	&mock_hal_sink_event_receiver_));

	ASSERT_NE(hal_sink_stream_cb.on_resume_, nullptr);

	/* Expect LeAudio registered event listener to get called when HAL calls the
	* client_audio's internal resume callback.
	*/
	EXPECT_CALL(mock_hal_sink_event_receiver_, OnAudioResume(_)).Times(1);
	bool start_media_task = false;
	ASSERT_TRUE(hal_sink_stream_cb.on_resume_(start_media_task));
	}