Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 58b5e436 authored by Mariusz Skamra's avatar Mariusz Skamra
Browse files

bta: le_audio: state_machine_test: Factor out DevicePacsInit method 

Factor out DevicePacsInit method, so that the PACS can be initiated
with differed values on each of test devices within the set.

Bug: 357472821
Flag: Exempt; mechanical refactor
Test: atest bluetooth_le_audio_test
Change-Id: Ic21b633e47ea7cc257edd11e1ff0509c2cf127c4
parent ff7a3be3

system/bta/le_audio/state_machine_test.cc

+139 −114
Original line number Diff line number Diff line
@@ -248,6 +248,8 @@ protected: 
  /* Use for single test to simulate late ASE notifications */

  bool stop_inject_configured_ase_after_first_ase_configured_;



  uint16_t pacs_attr_handle_next = ATTR_HANDLE_PACS_POOL_START;



  virtual void SetUp() override {

    __android_log_set_minimum_priority(ANDROID_LOG_DEBUG);

    reset_mock_function_count_map();
@@ -1032,20 +1034,70 @@ protected: 
            {.sink = snk_contexts_available, .source = src_contexts_available});



    auto group = GroupFindById(leAudioDevice->group_id_);

    ASSERT_NE(group, nullptr);

    if (group) {

      bool group_conf_changed = group->ReloadAudioLocations();

      group_conf_changed |= group->ReloadAudioDirections();

      group_conf_changed |= group->UpdateAudioContextAvailability();

      if (group_conf_changed) {

        /* All the configurations should be recalculated for the new conditions */

        group->InvalidateCachedConfigurations();

        group->InvalidateGroupStrategy();

      }

    }

  }



    /* Set the location and direction to the group (done in client.cc)*/

    group->ReloadAudioDirections();

  void DevicePacsInit(LeAudioDevice* leAudioDevice, uint8_t direction, uint8_t audio_locations,

                      types::AudioContexts contexts_available,

                      types::AudioContexts contexts_supported) {

    if ((direction & types::kLeAudioDirectionSink) > 0) {

      // Set target ASE configurations

      std::vector<types::acs_ac_record> pac_recs;



      InsertPacRecord(pac_recs, sample_freq_,

                      codec_specific::kCapFrameDuration10ms |

                              codec_specific::kCapFrameDuration7p5ms |

                              codec_specific::kCapFrameDuration10msPreferred,

                      channel_count_, 30, 120, codec_frame_blocks_per_sdu_);



      types::hdl_pair handle_pair;

      handle_pair.val_hdl = pacs_attr_handle_next++;

      handle_pair.ccc_hdl = pacs_attr_handle_next++;



      leAudioDevice->snk_pacs_.emplace_back(std::make_tuple(std::move(handle_pair), pac_recs));



      leAudioDevice->snk_audio_locations_ = audio_locations;

    }



    if ((direction & types::kLeAudioDirectionSource) > 0) {

      // Set target ASE configurations

      std::vector<types::acs_ac_record> pac_recs;



      InsertPacRecord(pac_recs,

                      codec_specific::kCapSamplingFrequency16000Hz |

                              codec_specific::kCapSamplingFrequency32000Hz,

                      codec_specific::kCapFrameDuration10ms |

                              codec_specific::kCapFrameDuration7p5ms |

                              codec_specific::kCapFrameDuration10msPreferred,

                      0b00000001, 30, 120, codec_frame_blocks_per_sdu_);



      types::hdl_pair handle_pair;

      handle_pair.val_hdl = pacs_attr_handle_next++;

      handle_pair.ccc_hdl = pacs_attr_handle_next++;



      leAudioDevice->src_pacs_.emplace_back(std::make_tuple(std::move(handle_pair), pac_recs));



      leAudioDevice->src_audio_locations_ = audio_locations;

    }



    DeviceContextsUpdate(leAudioDevice, direction, contexts_available, contexts_supported);

  }



  void MultipleTestDevicePrepare(int leaudio_group_id, LeAudioContextType context_type,

                                 uint16_t device_cnt, types::AudioContexts update_contexts,

                                 const uint16_t total_devices, types::AudioContexts update_contexts,

                                 bool insert_default_pac_records = true,

                                 bool second_device_0_ases = false) {

    // Prepare fake connected device group

    DeviceConnectState initial_connect_state = DeviceConnectState::CONNECTING_BY_USER;

    int total_devices = device_cnt;

    bluetooth::le_audio::LeAudioDeviceGroup* group = nullptr;



    uint8_t num_ase_snk;

    uint8_t num_ase_src;
@@ -1074,84 +1126,48 @@ protected: 
        ASSERT_TRUE(false);

    }



    while (device_cnt) {

    for (uint8_t device_cnt = 0; device_cnt < total_devices; device_cnt++) {

      std::shared_ptr<LeAudioDevice> leAudioDevice;

      bluetooth::le_audio::LeAudioDeviceGroup* group;



      if (device_cnt == 2 && second_device_0_ases == true) {

        leAudioDevice = PrepareConnectedDevice(device_cnt--, initial_connect_state, 0, 0);

      if (device_cnt == 1 && second_device_0_ases == true) {

        leAudioDevice = PrepareConnectedDevice(device_cnt, initial_connect_state, 0, 0);

      } else {

        leAudioDevice = PrepareConnectedDevice(device_cnt--, initial_connect_state, num_ase_snk,

                                               num_ase_src);

        leAudioDevice =

                PrepareConnectedDevice(device_cnt, initial_connect_state, num_ase_snk, num_ase_src);

      }



      if (insert_default_pac_records) {

        uint16_t attr_handle = ATTR_HANDLE_PACS_POOL_START;



        /* As per spec, unspecified shall be supported */

        auto snk_context_type = kContextTypeUnspecified | update_contexts;

        auto src_context_type = kContextTypeUnspecified | update_contexts;

      group = GroupTheDevice(leaudio_group_id, std::move(leAudioDevice));

      ASSERT_NE(group, nullptr);

      ASSERT_EQ(group->Size(), device_cnt + 1);



      if (insert_default_pac_records) {

        // Prepare Sink Published Audio Capability records

        if ((kContextTypeRingtone | kContextTypeMedia | kContextTypeConversational |

             kContextTypeLive)

                    .test(context_type)) {

          // Set target ASE configurations

          std::vector<types::acs_ac_record> pac_recs;



          InsertPacRecord(pac_recs, sample_freq_,

                          codec_specific::kCapFrameDuration10ms |

                                  codec_specific::kCapFrameDuration7p5ms |

                                  codec_specific::kCapFrameDuration10msPreferred,

                          channel_count_, 30, 120, codec_frame_blocks_per_sdu_);



          types::hdl_pair handle_pair;

          handle_pair.val_hdl = attr_handle++;

          handle_pair.ccc_hdl = attr_handle++;



          leAudioDevice->snk_pacs_.emplace_back(std::make_tuple(std::move(handle_pair), pac_recs));



          auto snk_context_type = update_contexts;

          snk_context_type.set(context_type);

          leAudioDevice->snk_audio_locations_ = channel_allocations_sink_;



          DevicePacsInit(leAudioDevice.get(), types::kLeAudioDirectionSink,

                         channel_allocations_sink_, snk_context_type, snk_context_type);

        }



        // Prepare Source Published Audio Capability records

        if ((context_type == kContextTypeConversational) || (context_type == kContextTypeLive)) {

          // Set target ASE configurations

          std::vector<types::acs_ac_record> pac_recs;



          InsertPacRecord(pac_recs,

                          codec_specific::kCapSamplingFrequency16000Hz |

                                  codec_specific::kCapSamplingFrequency32000Hz,

                          codec_specific::kCapFrameDuration10ms |

                                  codec_specific::kCapFrameDuration7p5ms |

                                  codec_specific::kCapFrameDuration10msPreferred,

                          0b00000001, 30, 120, codec_frame_blocks_per_sdu_);



          types::hdl_pair handle_pair;

          handle_pair.val_hdl = attr_handle++;

          handle_pair.ccc_hdl = attr_handle++;



          leAudioDevice->src_pacs_.emplace_back(std::make_tuple(std::move(handle_pair), pac_recs));

          auto src_context_type = update_contexts;

          src_context_type.set(context_type);



          leAudioDevice->src_audio_locations_ = channel_allocations_source_;

          DevicePacsInit(leAudioDevice.get(), types::kLeAudioDirectionSource,

                         channel_allocations_source_, src_context_type, src_context_type);

        }



        leAudioDevice->SetSupportedContexts({.sink = snk_context_type, .source = src_context_type});

        leAudioDevice->SetAvailableContexts({.sink = snk_context_type, .source = src_context_type});

      }



      group = GroupTheDevice(leaudio_group_id, std::move(leAudioDevice));

      /* Set the location and direction to the group (done in client.cc)*/

      group->ReloadAudioLocations();

      group->ReloadAudioDirections();

    }



    /* Stimulate update of available context map and configuration cache */

    group->UpdateAudioContextAvailability();

    group->UpdateAudioSetConfigurationCache(context_type);



    auto group = GroupFindById(leaudio_group_id);

    ASSERT_NE(group, nullptr);



    group->UpdateAudioSetConfigurationCache(context_type);

    ASSERT_EQ(group->Size(), total_devices);

  }
@@ -1674,7 +1690,8 @@ TEST_F(StateMachineTest, testConfigureCodecSingle) { 
  /* Start the configuration and stream Media content.

   * Expect 1 time for the Codec Config call only. */

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(1);



  /* Do nothing on the CigCreate, so the state machine stays in the configure
@@ -1892,7 +1909,8 @@ TEST_F(StateMachineTest, testConfigureQosSingle) { 


  // Start the configuration and stream Media content

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -1939,7 +1957,8 @@ TEST_F(StateMachineTest, testConfigureQosSingleRecoverCig) { 


  // Start the configuration and stream Media content

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(2);
@@ -2139,7 +2158,8 @@ TEST_F(StateMachineTest, testStreamCreationError) { 
   * 4 - Release ASE

   */

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(4);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -2188,7 +2208,8 @@ TEST_F(StateMachineTest, testStreamSingle) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -2239,7 +2260,8 @@ TEST_F(StateMachineTest, testStreamSingleRetryCisFailure) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(4);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -2291,7 +2313,8 @@ TEST_F(StateMachineTest, testStreamSingleRetryCisSuccess) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -2350,7 +2373,8 @@ TEST_F(StateMachineTest, testStreamSkipEnablingSink) { 
   */

  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(4);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -2408,7 +2432,8 @@ TEST_F(StateMachineTest, testStreamSkipEnablingSinkSource) { 
   */

  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(4);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -2464,32 +2489,25 @@ TEST_F(StateMachineTest, testStreamMultipleMedia_OneMemberHasNoAses) { 


  /* Check there are two devices*/

  auto* leAudioDevice = group->GetFirstDevice();

  LeAudioDevice* lastDevice = nullptr;

  auto* secondDevice = group->GetNextDevice(leAudioDevice);

  /*

   * First set member has no ASEs, no operations on control point are expected

   * Second set member has no ASEs, no operations on control point are expected

   * 0

   */

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

              WriteCharacteristic(secondDevice->conn_id_, secondDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(0);



  auto expected_devices_written = 0;

  while (leAudioDevice) {

    expected_devices_written++;

    lastDevice = leAudioDevice;

    leAudioDevice = group->GetNextDevice(leAudioDevice);

  }

  ASSERT_EQ(expected_devices_written, num_devices);



  /*

   * Second device will be configured for Streaming. Expecting 3 operations:

   * First device will be configured for Streaming. Expecting 3 operations:

   * 1. Codec Config

   * 2. QoS Config

   * 3. Enable

   */

  EXPECT_CALL(gatt_queue, WriteCharacteristic(lastDevice->conn_id_, lastDevice->ctp_hdls_.val_hdl,

                                              _, GATT_WRITE_NO_RSP, _, _))

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  // Validate GroupStreamStatus
@@ -2534,35 +2552,28 @@ TEST_F(StateMachineTest, testStreamMultipleMedia_OneMemberHasNoAsesAndNotConnect 


  /* Check there are two devices*/

  auto* leAudioDevice = group->GetFirstDevice();

  LeAudioDevice* lastDevice = nullptr;

  auto* secondDevice = group->GetNextDevice(leAudioDevice);

  /*

   * First set member has no ASEs, no operations on control point are expected

   * Second set member has no ASEs, no operations on control point are expected

   * 0

   */

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

              WriteCharacteristic(secondDevice->conn_id_, secondDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(0);



  /* Device with 0 Ases is disconnected */

  InjectAclDisconnected(group, leAudioDevice);



  auto expected_devices_written = 0;

  while (leAudioDevice) {

    expected_devices_written++;

    lastDevice = leAudioDevice;

    leAudioDevice = group->GetNextDevice(leAudioDevice);

  }

  ASSERT_EQ(expected_devices_written, num_devices);

  InjectAclDisconnected(group, secondDevice);



  /*

   * Second device will be configured for Streaming. Expecting 3 operations:

   * First device will be configured for Streaming. Expecting 3 operations:

   * 1. Codec Config

   * 2. QoS Config

   * 3. Enable

   */

  EXPECT_CALL(gatt_queue, WriteCharacteristic(lastDevice->conn_id_, lastDevice->ctp_hdls_.val_hdl,

                                              _, GATT_WRITE_NO_RSP, _, _))

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  // Validate GroupStreamStatus
@@ -3127,7 +3138,8 @@ TEST_F(StateMachineTest, testDisableSingle) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(4);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -3257,7 +3269,8 @@ TEST_F(StateMachineTest, testDisableBidirectional) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(AtLeast(4));



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -3354,7 +3367,8 @@ TEST_F(StateMachineTest, testReleaseSingle) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(4);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -3411,7 +3425,8 @@ TEST_F(StateMachineTest, testReleaseCachingSingle) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(4);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -3481,7 +3496,8 @@ TEST_F(StateMachineTest, testStreamCaching_NoReconfigurationNeeded_SingleDevice) 
   */

  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(6);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(2);
@@ -3571,7 +3587,8 @@ TEST_F(StateMachineTest, test_StreamCaching_ReconfigureForContextChange_SingleDe 
   */

  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(8);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(2);
@@ -3908,7 +3925,8 @@ TEST_F(StateMachineTest, testReleaseBidirectional) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(AtLeast(4));



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -3964,7 +3982,8 @@ TEST_F(StateMachineTest, testDisableAndReleaseBidirectional) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(AtLeast(4));



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(1);
@@ -4415,7 +4434,8 @@ TEST_F(StateMachineTest, testStateTransitionTimeoutOnIdleState) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(1);



  // Start the configuration and stream Media content
@@ -4473,7 +4493,8 @@ TEST_F(StateMachineTest, testStateTransitionTimeout) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  // Start the configuration and stream Media content
@@ -4500,7 +4521,8 @@ TEST_F(StateMachineTest, testStateTransitionTimeoutAndDisconnectWhenConfigured) 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(1);



  InjectInitialConfiguredNotification(group);
@@ -4551,7 +4573,8 @@ TEST_F(StateMachineTest, testStateTransitionTimeoutAndDisconnectWhenQoSConfigure 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(2);



  InjectInitialConfiguredNotification(group);
@@ -4603,7 +4626,8 @@ TEST_F(StateMachineTest, testStateTransitionTimeoutAndDisconnectWhenEnabling) { 


  auto* leAudioDevice = group->GetFirstDevice();

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(3);



  InjectInitialConfiguredNotification(group);
@@ -8607,7 +8631,8 @@ TEST_F(StateMachineTest, testStopStreamBeforeCodecConfigureIsArrived) { 
   * 2 - Release ASE

   */

  EXPECT_CALL(gatt_queue,

              WriteCharacteristic(1, leAudioDevice->ctp_hdls_.val_hdl, _, GATT_WRITE_NO_RSP, _, _))

              WriteCharacteristic(leAudioDevice->conn_id_, leAudioDevice->ctp_hdls_.val_hdl, _,

                                  GATT_WRITE_NO_RSP, _, _))

          .Times(2);



  EXPECT_CALL(*mock_iso_manager_, CreateCig(_, _)).Times(0);