| // Copyright 2023 The Pigweed Authors |
| // |
| // 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 |
| // |
| // https://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 "pw_bluetooth_sapphire/internal/host/hci/low_energy_advertiser.h" |
| |
| #include "pw_bluetooth_sapphire/internal/host/hci/android_extended_low_energy_advertiser.h" |
| #include "pw_bluetooth_sapphire/internal/host/hci/extended_low_energy_advertiser.h" |
| #include "pw_bluetooth_sapphire/internal/host/hci/legacy_low_energy_advertiser.h" |
| #include "pw_bluetooth_sapphire/internal/host/testing/controller_test.h" |
| #include "pw_bluetooth_sapphire/internal/host/testing/fake_controller.h" |
| #include "pw_bluetooth_sapphire/internal/host/testing/fake_peer.h" |
| #include "pw_bluetooth_sapphire/internal/host/testing/test_helpers.h" |
| |
| // LowEnergyAdvertiser has many potential subclasses (e.g. |
| // LegacyLowEnergyAdvertiser, ExtendedLowEnergyAdvertiser, |
| // AndroidExtendedLowEnergyAdvertiser, etc). The unique features of these |
| // subclass are tested individually in their own unittest files. However, there |
| // are some common features that all LowEnergyAdvertisers should follow. This |
| // class implements a type parameterized test to exercise those common features. |
| // |
| // If you add a new subclass of LowEnergyAdvertiser in the future, make sure to |
| // add its type to the list of types below (in the TYPED_TEST_SUITE) so that its |
| // common features are exercised as well. |
| |
| namespace bt::hci { |
| namespace { |
| |
| using bt::testing::FakeController; |
| using bt::testing::FakePeer; |
| |
| using AdvertisingOptions = LowEnergyAdvertiser::AdvertisingOptions; |
| using TestingBase = bt::testing::FakeDispatcherControllerTest<FakeController>; |
| |
| constexpr hci_spec::ConnectionHandle kConnectionHandle = 0x0001; |
| constexpr AdvertisingIntervalRange kTestInterval( |
| hci_spec::kLEAdvertisingIntervalMin, hci_spec::kLEAdvertisingIntervalMax); |
| |
| const DeviceAddress kPublicAddress(DeviceAddress::Type::kLEPublic, {1}); |
| const DeviceAddress kRandomAddress(DeviceAddress::Type::kLERandom, {2}); |
| |
| // Various parts of the Bluetooth Core Spec require that advertising interval |
| // min and max are not the same value. We shouldn't allow it either. For |
| // example, Core Spec Volume 4, Part E, Section 7.8.5: "The |
| // Advertising_Interval_Min and Advertising_Interval_Max should not be the same |
| // value to enable the Controller to determine the best advertising interval |
| // given other activities." |
| TEST(AdvertisingIntervalRangeDeathTest, MaxMinNotSame) { |
| EXPECT_DEATH(AdvertisingIntervalRange(hci_spec::kLEAdvertisingIntervalMin, |
| hci_spec::kLEAdvertisingIntervalMin), |
| ".*"); |
| } |
| |
| TEST(AdvertisingIntervalRangeDeathTest, MinLessThanMax) { |
| EXPECT_DEATH(AdvertisingIntervalRange(hci_spec::kLEAdvertisingIntervalMax, |
| hci_spec::kLEAdvertisingIntervalMin), |
| ".*"); |
| } |
| |
| template <typename T> |
| class LowEnergyAdvertiserTest : public TestingBase { |
| public: |
| LowEnergyAdvertiserTest() = default; |
| ~LowEnergyAdvertiserTest() override = default; |
| |
| protected: |
| void SetUp() override { |
| TestingBase::SetUp(); |
| |
| // ACL data channel needs to be present for production hci::Connection |
| // objects. |
| TestingBase::InitializeACLDataChannel( |
| hci::DataBufferInfo(), |
| hci::DataBufferInfo(hci_spec::kMaxACLPayloadSize, 10)); |
| |
| FakeController::Settings settings; |
| settings.ApplyLegacyLEConfig(); |
| settings.bd_addr = kPublicAddress; |
| test_device()->set_settings(settings); |
| |
| advertiser_ = std::unique_ptr<T>(CreateAdvertiserInternal()); |
| |
| test_device()->set_num_supported_advertising_sets(0xEF); |
| } |
| |
| void TearDown() override { |
| advertiser_ = nullptr; |
| TestingBase::TearDown(); |
| } |
| |
| template <bool same = std::is_same_v<T, AndroidExtendedLowEnergyAdvertiser>> |
| std::enable_if_t<same, AndroidExtendedLowEnergyAdvertiser>* |
| CreateAdvertiserInternal() { |
| return new AndroidExtendedLowEnergyAdvertiser(transport()->GetWeakPtr(), 1); |
| } |
| |
| template <bool same = std::is_same_v<T, ExtendedLowEnergyAdvertiser>> |
| std::enable_if_t<same, ExtendedLowEnergyAdvertiser>* |
| CreateAdvertiserInternal() { |
| return new ExtendedLowEnergyAdvertiser(transport()->GetWeakPtr()); |
| } |
| |
| template <bool same = std::is_same_v<T, LegacyLowEnergyAdvertiser>> |
| std::enable_if_t<same, LegacyLowEnergyAdvertiser>* |
| CreateAdvertiserInternal() { |
| return new LegacyLowEnergyAdvertiser(transport()->GetWeakPtr()); |
| } |
| |
| LowEnergyAdvertiser* advertiser() const { return advertiser_.get(); } |
| |
| void DestroyAdvertiser() { advertiser_.reset(); } |
| |
| ResultFunction<> MakeExpectSuccessCallback() { |
| return [this](Result<> status) { |
| last_status_ = status; |
| EXPECT_EQ(fit::ok(), status); |
| }; |
| } |
| |
| ResultFunction<> MakeExpectErrorCallback() { |
| return [this](Result<> status) { |
| last_status_ = status; |
| EXPECT_TRUE(status.is_error()); |
| }; |
| } |
| |
| std::optional<Result<>> GetLastStatus() { |
| if (!last_status_) { |
| return std::nullopt; |
| } |
| |
| Result<> status = last_status_.value(); |
| last_status_.reset(); |
| return status; |
| } |
| |
| // Makes some fake advertising data. |
| // |include_flags| signals whether to include flag encoding size in the data |
| // calculation. |
| AdvertisingData GetExampleData(bool include_flags = true) { |
| AdvertisingData result; |
| |
| auto name = "fuchsia"; |
| EXPECT_TRUE(result.SetLocalName(name)); |
| |
| auto appearance = 0x1234; |
| result.SetAppearance(appearance); |
| |
| EXPECT_LE(result.CalculateBlockSize(include_flags), |
| hci_spec::kMaxLEAdvertisingDataLength); |
| return result; |
| } |
| |
| // Makes fake advertising data that is too large. |
| // |include_flags| signals whether to include flag encoding size in the data |
| // calculation. |
| AdvertisingData GetTooLargeExampleData( |
| bool include_flags, |
| std::size_t size = hci_spec::kMaxLEAdvertisingDataLength + 1) { |
| AdvertisingData result; |
| |
| if (include_flags) { |
| size -= kTLVFlagsSize; |
| } |
| |
| std::ostringstream oss; |
| for (unsigned int i = 0; i <= size; i++) { |
| oss << 'a'; |
| } |
| |
| EXPECT_TRUE(result.SetLocalName(oss.str())); |
| |
| // The maximum advertisement packet is: |
| // |hci_spec::kMaxLEAdvertisingDataLength| = 31, and |result| = 32 bytes. |
| // |result| should be too large to advertise. |
| EXPECT_GT(result.CalculateBlockSize(include_flags), |
| hci_spec::kMaxLEAdvertisingDataLength); |
| return result; |
| } |
| |
| std::optional<hci_spec::AdvertisingHandle> CurrentAdvertisingHandle() const { |
| if (std::is_same_v<T, ExtendedLowEnergyAdvertiser>) { |
| auto extended = static_cast<ExtendedLowEnergyAdvertiser*>(advertiser()); |
| return extended->LastUsedHandleForTesting(); |
| } |
| |
| if (std::is_same_v<T, AndroidExtendedLowEnergyAdvertiser>) { |
| auto extended = |
| static_cast<AndroidExtendedLowEnergyAdvertiser*>(advertiser()); |
| return extended->LastUsedHandleForTesting(); |
| } |
| |
| return 0; // non-extended advertising doesn't use handles, we can return |
| // any value |
| } |
| |
| const FakeController::LEAdvertisingState& GetControllerAdvertisingState() |
| const { |
| if (std::is_same_v<T, LegacyLowEnergyAdvertiser>) { |
| return test_device()->legacy_advertising_state(); |
| } |
| |
| if (std::is_same_v<T, ExtendedLowEnergyAdvertiser> || |
| std::is_same_v<T, AndroidExtendedLowEnergyAdvertiser>) { |
| std::optional<hci_spec::AdvertisingHandle> handle = |
| CurrentAdvertisingHandle(); |
| if (!handle) { |
| static FakeController::LEAdvertisingState empty; |
| return empty; |
| } |
| |
| return test_device()->extended_advertising_state(handle.value()); |
| } |
| |
| EXPECT_TRUE(false) << "advertiser is of unknown type"; |
| |
| // return something in order to compile, tests will fail if they get here |
| static FakeController::LEAdvertisingState state; |
| return state; |
| } |
| |
| void MaybeSendMultipleAdvertisingPostConnectionEvents( |
| hci_spec::ConnectionHandle conn_handle, |
| hci_spec::AdvertisingHandle adv_handle) { |
| if (std::is_same_v<T, AndroidExtendedLowEnergyAdvertiser>) { |
| test_device()->SendAndroidLEMultipleAdvertisingStateChangeSubevent( |
| conn_handle, adv_handle); |
| return; |
| } |
| |
| if (std::is_same_v<T, ExtendedLowEnergyAdvertiser>) { |
| test_device()->SendLEAdvertisingSetTerminatedEvent(conn_handle, |
| adv_handle); |
| return; |
| } |
| } |
| |
| private: |
| std::unique_ptr<LowEnergyAdvertiser> advertiser_; |
| std::optional<Result<>> last_status_; |
| |
| BT_DISALLOW_COPY_AND_ASSIGN_ALLOW_MOVE(LowEnergyAdvertiserTest); |
| }; |
| |
| using Implementations = ::testing::Types<LegacyLowEnergyAdvertiser, |
| ExtendedLowEnergyAdvertiser, |
| AndroidExtendedLowEnergyAdvertiser>; |
| TYPED_TEST_SUITE(LowEnergyAdvertiserTest, Implementations); |
| |
| // - Stops the advertisement when an incoming connection comes in |
| // - Possible to restart advertising |
| // - Advertising state cleaned up between calls |
| TYPED_TEST(LowEnergyAdvertiserTest, ConnectionTest) { |
| AdvertisingData adv_data = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| std::unique_ptr<LowEnergyConnection> link; |
| auto conn_cb = [&link](auto cb_link) { link = std::move(cb_link); }; |
| |
| // Start advertising kPublicAddress |
| this->advertiser()->StartAdvertising(kPublicAddress, |
| adv_data, |
| scan_data, |
| options, |
| conn_cb, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->advertiser()->IsAdvertising()); |
| EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress)); |
| |
| // Accept a connection and ensure that connection state is set up correctly |
| link.reset(); |
| this->advertiser()->OnIncomingConnection( |
| kConnectionHandle, |
| pw::bluetooth::emboss::ConnectionRole::PERIPHERAL, |
| kRandomAddress, |
| hci_spec::LEConnectionParameters()); |
| std::optional<hci_spec::AdvertisingHandle> handle = |
| this->CurrentAdvertisingHandle(); |
| ASSERT_TRUE(handle); |
| this->MaybeSendMultipleAdvertisingPostConnectionEvents(kConnectionHandle, |
| handle.value()); |
| this->RunUntilIdle(); |
| |
| ASSERT_TRUE(link); |
| EXPECT_EQ(kConnectionHandle, link->handle()); |
| EXPECT_EQ(kPublicAddress, link->local_address()); |
| EXPECT_EQ(kRandomAddress, link->peer_address()); |
| EXPECT_FALSE(this->advertiser()->IsAdvertising()); |
| EXPECT_FALSE(this->advertiser()->IsAdvertising(kPublicAddress)); |
| |
| // Advertising state should get cleared on a disconnection |
| link->Disconnect( |
| pw::bluetooth::emboss::StatusCode::REMOTE_USER_TERMINATED_CONNECTION); |
| this->test_device()->SendDisconnectionCompleteEvent(link->handle()); |
| this->RunUntilIdle(); |
| EXPECT_FALSE(this->GetControllerAdvertisingState().enabled); |
| |
| // Restart advertising using a different local address |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| adv_data, |
| scan_data, |
| options, |
| conn_cb, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| |
| // Accept a connection from kPublicAddress. The internal advertising state |
| // should get assigned correctly with no remnants of the previous advertise. |
| link.reset(); |
| this->advertiser()->OnIncomingConnection( |
| kConnectionHandle, |
| pw::bluetooth::emboss::ConnectionRole::PERIPHERAL, |
| kPublicAddress, |
| hci_spec::LEConnectionParameters()); |
| handle = this->CurrentAdvertisingHandle(); |
| ASSERT_TRUE(handle); |
| this->MaybeSendMultipleAdvertisingPostConnectionEvents(kConnectionHandle, |
| handle.value()); |
| this->RunUntilIdle(); |
| |
| ASSERT_TRUE(link); |
| EXPECT_EQ(kRandomAddress, link->local_address()); |
| EXPECT_EQ(kPublicAddress, link->peer_address()); |
| } |
| |
| // Tests that advertising can be restarted right away in a connection callback. |
| TYPED_TEST(LowEnergyAdvertiserTest, RestartInConnectionCallback) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| std::unique_ptr<LowEnergyConnection> link; |
| auto conn_cb = [&, this](auto cb_link) { |
| link = std::move(cb_link); |
| |
| this->advertiser()->StartAdvertising( |
| kPublicAddress, |
| ad, |
| scan_data, |
| options, |
| [](auto) { /*noop*/ }, |
| this->MakeExpectSuccessCallback()); |
| }; |
| |
| this->advertiser()->StartAdvertising(kPublicAddress, |
| ad, |
| scan_data, |
| options, |
| conn_cb, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| |
| bool enabled = true; |
| std::vector<bool> adv_states; |
| this->test_device()->set_advertising_state_callback( |
| [this, &adv_states, &enabled] { |
| bool new_enabled = this->GetControllerAdvertisingState().enabled; |
| if (enabled != new_enabled) { |
| adv_states.push_back(new_enabled); |
| enabled = new_enabled; |
| } |
| }); |
| |
| this->advertiser()->OnIncomingConnection( |
| kConnectionHandle, |
| pw::bluetooth::emboss::ConnectionRole::PERIPHERAL, |
| kRandomAddress, |
| hci_spec::LEConnectionParameters()); |
| std::optional<hci_spec::AdvertisingHandle> handle = |
| this->CurrentAdvertisingHandle(); |
| ASSERT_TRUE(handle); |
| this->MaybeSendMultipleAdvertisingPostConnectionEvents(kConnectionHandle, |
| handle.value()); |
| |
| // Advertising should get disabled and re-enabled. |
| this->RunUntilIdle(); |
| ASSERT_EQ(2u, adv_states.size()); |
| EXPECT_FALSE(adv_states[0]); |
| EXPECT_TRUE(adv_states[1]); |
| |
| this->test_device()->set_advertising_state_callback(nullptr); |
| } |
| |
| // An incoming connection when not advertising should get disconnected. |
| TYPED_TEST(LowEnergyAdvertiserTest, IncomingConnectionWhenNotAdvertising) { |
| std::vector<std::pair<bool, hci_spec::ConnectionHandle>> connection_states; |
| this->test_device()->set_connection_state_callback( |
| [&](const auto& address, auto handle, bool connected, bool canceled) { |
| EXPECT_EQ(kRandomAddress, address); |
| EXPECT_FALSE(canceled); |
| connection_states.push_back(std::make_pair(connected, handle)); |
| }); |
| |
| auto fake_peer = std::make_unique<FakePeer>( |
| kRandomAddress, TestFixture::dispatcher(), true, true); |
| this->test_device()->AddPeer(std::move(fake_peer)); |
| this->test_device()->ConnectLowEnergy( |
| kRandomAddress, pw::bluetooth::emboss::ConnectionRole::PERIPHERAL); |
| this->RunUntilIdle(); |
| |
| ASSERT_EQ(1u, connection_states.size()); |
| auto [connection_state, handle] = connection_states[0]; |
| EXPECT_TRUE(connection_state); |
| |
| // Notify the advertiser of the incoming connection. It should reject it and |
| // the controller should become disconnected. |
| this->advertiser()->OnIncomingConnection( |
| handle, |
| pw::bluetooth::emboss::ConnectionRole::PERIPHERAL, |
| kRandomAddress, |
| hci_spec::LEConnectionParameters()); |
| this->MaybeSendMultipleAdvertisingPostConnectionEvents(kConnectionHandle, 0); |
| this->RunUntilIdle(); |
| ASSERT_EQ(2u, connection_states.size()); |
| auto [connection_state_after_disconnect, disconnected_handle] = |
| connection_states[1]; |
| EXPECT_EQ(handle, disconnected_handle); |
| EXPECT_FALSE(connection_state_after_disconnect); |
| } |
| |
| // An incoming connection during non-connectable advertising should get |
| // disconnected. |
| TYPED_TEST(LowEnergyAdvertiserTest, |
| IncomingConnectionWhenNonConnectableAdvertising) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| this->advertiser()->StartAdvertising(kPublicAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| ASSERT_TRUE(this->GetLastStatus()); |
| |
| std::vector<std::pair<bool, hci_spec::ConnectionHandle>> connection_states; |
| this->test_device()->set_connection_state_callback( |
| [&](const auto& address, auto handle, bool connected, bool canceled) { |
| EXPECT_EQ(kRandomAddress, address); |
| EXPECT_FALSE(canceled); |
| connection_states.push_back(std::make_pair(connected, handle)); |
| }); |
| |
| auto fake_peer = std::make_unique<FakePeer>( |
| kRandomAddress, TestFixture::dispatcher(), true, true); |
| this->test_device()->AddPeer(std::move(fake_peer)); |
| this->test_device()->ConnectLowEnergy( |
| kRandomAddress, pw::bluetooth::emboss::ConnectionRole::PERIPHERAL); |
| this->RunUntilIdle(); |
| |
| ASSERT_EQ(1u, connection_states.size()); |
| auto [connection_state, handle] = connection_states[0]; |
| EXPECT_TRUE(connection_state); |
| |
| // Notify the advertiser of the incoming connection. It should reject it and |
| // the controller should become disconnected. |
| this->advertiser()->OnIncomingConnection( |
| handle, |
| pw::bluetooth::emboss::ConnectionRole::PERIPHERAL, |
| kRandomAddress, |
| hci_spec::LEConnectionParameters()); |
| this->MaybeSendMultipleAdvertisingPostConnectionEvents(kConnectionHandle, 0); |
| this->RunUntilIdle(); |
| ASSERT_EQ(2u, connection_states.size()); |
| auto [connection_state_after_disconnect, disconnected_handle] = |
| connection_states[1]; |
| EXPECT_EQ(handle, disconnected_handle); |
| EXPECT_FALSE(connection_state_after_disconnect); |
| } |
| |
| // Tests starting and stopping an advertisement. |
| TYPED_TEST(LowEnergyAdvertiserTest, StartAndStop) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| |
| this->advertiser()->StopAdvertising(kRandomAddress); |
| this->RunUntilIdle(); |
| EXPECT_FALSE(this->GetControllerAdvertisingState().enabled); |
| } |
| |
| // Tests that an advertisement is configured with the correct parameters. |
| TYPED_TEST(LowEnergyAdvertiserTest, AdvertisingParameters) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| auto flags = AdvFlag::kLEGeneralDiscoverableMode; |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| flags, |
| /*include_tx_power_level=*/false); |
| |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| // The expected advertisement including the Flags. |
| DynamicByteBuffer expected_ad(ad.CalculateBlockSize(/*include_flags=*/true)); |
| ad.WriteBlock(&expected_ad, flags); |
| |
| DynamicByteBuffer expected_scan_data( |
| scan_data.CalculateBlockSize(/*include_flags=*/false)); |
| scan_data.WriteBlock(&expected_scan_data, std::nullopt); |
| |
| std::optional<FakeController::LEAdvertisingState> state = |
| this->GetControllerAdvertisingState(); |
| EXPECT_TRUE(state); |
| EXPECT_TRUE(state->enabled); |
| EXPECT_EQ(kTestInterval.min(), state->interval_min); |
| EXPECT_EQ(kTestInterval.max(), state->interval_max); |
| EXPECT_EQ(expected_ad, state->advertised_view()); |
| EXPECT_EQ(expected_scan_data, state->scan_rsp_view()); |
| EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM, |
| state->own_address_type); |
| |
| // Restart advertising with a public address and verify that the configured |
| // local address type is correct. |
| this->advertiser()->StopAdvertising(kRandomAddress); |
| AdvertisingOptions new_options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| this->advertiser()->StartAdvertising(kPublicAddress, |
| ad, |
| scan_data, |
| new_options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| state = this->GetControllerAdvertisingState(); |
| EXPECT_TRUE(state); |
| EXPECT_TRUE(state->enabled); |
| EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC, |
| state->own_address_type); |
| } |
| |
| // Tests that a previous advertisement's advertising data isn't accidentally |
| // kept around. This test was added to address fxbug.dev/42081491. |
| TYPED_TEST(LowEnergyAdvertiserTest, PreviousAdvertisingParameters) { |
| AdvertisingData scan_data = this->GetExampleData(); |
| auto flags = AdvFlag::kLEGeneralDiscoverableMode; |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| flags, |
| /*include_tx_power_level=*/false); |
| |
| // old advertising data: ideally we would fill this completely so that in the |
| // next start advertising call, we can confirm that none of the remnants are |
| // left. However, doing so results in the advertising data being too long. |
| // Instead, we rely on other unit tests within advertising data unittests to |
| // ensure all previous remnants are removed. |
| AdvertisingData ad; |
| ad.SetTxPower(4); |
| ad.SetAppearance(0x4567); |
| EXPECT_TRUE(ad.SetLocalName("fuchsia")); |
| |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| // new advertising data (with fewer fields filled in) |
| this->advertiser()->StopAdvertising(kRandomAddress); |
| AdvertisingData new_ad = this->GetExampleData(); |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| new_ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| DynamicByteBuffer expected_ad( |
| new_ad.CalculateBlockSize(/*include_flags=*/true)); |
| new_ad.WriteBlock(&expected_ad, flags); |
| |
| std::optional<FakeController::LEAdvertisingState> state = |
| this->GetControllerAdvertisingState(); |
| EXPECT_EQ(expected_ad, state->advertised_view()); |
| } |
| |
| // Tests that advertising interval values are capped within the allowed range. |
| TYPED_TEST(LowEnergyAdvertiserTest, AdvertisingIntervalWithinAllowedRange) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| |
| // Pass min and max values that are outside the allowed range. These should be |
| // capped. |
| constexpr AdvertisingIntervalRange interval( |
| hci_spec::kLEAdvertisingIntervalMin - 1, |
| hci_spec::kLEAdvertisingIntervalMax + 1); |
| AdvertisingOptions options(interval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| std::optional<FakeController::LEAdvertisingState> state = |
| this->GetControllerAdvertisingState(); |
| EXPECT_TRUE(state); |
| EXPECT_EQ(hci_spec::kLEAdvertisingIntervalMin, state->interval_min); |
| EXPECT_EQ(hci_spec::kLEAdvertisingIntervalMax, state->interval_max); |
| |
| // Reconfigure with values that are within the range. These should get passed |
| // down as is. |
| const AdvertisingIntervalRange new_interval( |
| hci_spec::kLEAdvertisingIntervalMin + 1, |
| hci_spec::kLEAdvertisingIntervalMax - 1); |
| AdvertisingOptions new_options(new_interval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| new_options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| state = this->GetControllerAdvertisingState(); |
| EXPECT_TRUE(state); |
| EXPECT_EQ(new_interval.min(), state->interval_min); |
| EXPECT_EQ(new_interval.max(), state->interval_max); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, StartWhileStarting) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| DeviceAddress addr = kRandomAddress; |
| |
| const AdvertisingIntervalRange old_interval = kTestInterval; |
| AdvertisingOptions old_options(old_interval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| const AdvertisingIntervalRange new_interval(kTestInterval.min() + 1, |
| kTestInterval.max() - 1); |
| AdvertisingOptions new_options(new_interval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| this->advertiser()->StartAdvertising( |
| addr, ad, scan_data, old_options, nullptr, [](auto) {}); |
| EXPECT_FALSE(this->GetControllerAdvertisingState().enabled); |
| |
| // This call should override the previous call and succeed with the new |
| // parameters. |
| this->advertiser()->StartAdvertising(addr, |
| ad, |
| scan_data, |
| new_options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| EXPECT_EQ(new_interval.max(), |
| this->GetControllerAdvertisingState().interval_max); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, StartWhileStopping) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| DeviceAddress addr = kRandomAddress; |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| // Get to a started state. |
| this->advertiser()->StartAdvertising( |
| addr, ad, scan_data, options, nullptr, this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| |
| // Initiate a request to Stop and wait until it's partially in progress. |
| bool enabled = true; |
| bool was_disabled = false; |
| auto adv_state_cb = [&] { |
| enabled = this->GetControllerAdvertisingState().enabled; |
| if (!was_disabled && !enabled) { |
| was_disabled = true; |
| |
| // Starting now should cancel the stop sequence and succeed. |
| this->advertiser()->StartAdvertising(addr, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| } |
| }; |
| this->test_device()->set_advertising_state_callback(adv_state_cb); |
| |
| this->advertiser()->StopAdvertising(addr); |
| |
| // Advertising should have been momentarily disabled. |
| this->RunUntilIdle(); |
| EXPECT_TRUE(was_disabled); |
| EXPECT_TRUE(enabled); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| |
| this->test_device()->set_advertising_state_callback(nullptr); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, StopWhileStarting) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| this->advertiser()->StartAdvertising(kPublicAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectErrorCallback()); |
| this->advertiser()->StopAdvertising(); |
| |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_FALSE(this->GetControllerAdvertisingState().enabled); |
| } |
| |
| // - StopAdvertisement noops when the advertisement address is wrong |
| // - Sets the advertisement data to null when stopped to prevent data leakage |
| // (re-enable advertising without changing data, intercept) |
| TYPED_TEST(LowEnergyAdvertiserTest, StopAdvertisingConditions) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| |
| this->RunUntilIdle(); |
| |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| DynamicByteBuffer expected_ad(ad.CalculateBlockSize(/*include_flags=*/true)); |
| ad.WriteBlock(&expected_ad, kDefaultNoAdvFlags); |
| EXPECT_TRUE(ContainersEqual( |
| this->GetControllerAdvertisingState().advertised_view(), expected_ad)); |
| |
| this->RunUntilIdle(); |
| this->advertiser()->StopAdvertising(kPublicAddress); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| EXPECT_TRUE(ContainersEqual( |
| this->GetControllerAdvertisingState().advertised_view(), expected_ad)); |
| |
| this->advertiser()->StopAdvertising(kRandomAddress); |
| |
| this->RunUntilIdle(); |
| EXPECT_FALSE(this->GetControllerAdvertisingState().enabled); |
| EXPECT_EQ(0u, this->GetControllerAdvertisingState().advertised_view().size()); |
| EXPECT_EQ(0u, this->GetControllerAdvertisingState().scan_rsp_view().size()); |
| } |
| |
| // - Updates data and params for the same address when advertising already |
| TYPED_TEST(LowEnergyAdvertiserTest, AdvertiseUpdate) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| |
| // The expected advertising data payload, with the flags. |
| DynamicByteBuffer expected_ad(ad.CalculateBlockSize(/*include_flags=*/true)); |
| ad.WriteBlock(&expected_ad, kDefaultNoAdvFlags); |
| EXPECT_TRUE(ContainersEqual( |
| this->GetControllerAdvertisingState().advertised_view(), expected_ad)); |
| |
| EXPECT_EQ(kTestInterval.min(), |
| this->GetControllerAdvertisingState().interval_min); |
| EXPECT_EQ(kTestInterval.max(), |
| this->GetControllerAdvertisingState().interval_max); |
| |
| uint16_t new_appearance = 0x6789; |
| ad.SetAppearance(new_appearance); |
| |
| const AdvertisingIntervalRange new_interval(kTestInterval.min() + 1, |
| kTestInterval.max() - 1); |
| AdvertisingOptions new_options(new_interval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| new_options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_TRUE(this->GetControllerAdvertisingState().enabled); |
| |
| DynamicByteBuffer expected_new_ad( |
| ad.CalculateBlockSize(/*include_flags=*/true)); |
| ad.WriteBlock(&expected_new_ad, kDefaultNoAdvFlags); |
| EXPECT_TRUE( |
| ContainersEqual(this->GetControllerAdvertisingState().advertised_view(), |
| expected_new_ad)); |
| |
| EXPECT_EQ(new_interval.min(), |
| this->GetControllerAdvertisingState().interval_min); |
| EXPECT_EQ(new_interval.max(), |
| this->GetControllerAdvertisingState().interval_max); |
| } |
| |
| // Ensures advertising set data is removed from controller memory after |
| // advertising is stopped |
| TYPED_TEST(LowEnergyAdvertiserTest, StopAdvertisingSingleAdvertisement) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| |
| // start public address advertising |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| this->advertiser()->StartAdvertising(kPublicAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectSuccessCallback()); |
| this->RunUntilIdle(); |
| EXPECT_TRUE(this->GetLastStatus()); |
| |
| constexpr uint8_t blank[hci_spec::kMaxLEAdvertisingDataLength] = {0}; |
| |
| // check that advertiser and controller both report the same advertising state |
| EXPECT_TRUE(this->advertiser()->IsAdvertising()); |
| EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress)); |
| |
| { |
| const FakeController::LEAdvertisingState& state = |
| this->GetControllerAdvertisingState(); |
| EXPECT_TRUE(state.enabled); |
| EXPECT_NE( |
| 0, |
| std::memcmp(blank, state.data, hci_spec::kMaxLEAdvertisingDataLength)); |
| EXPECT_NE(0, state.data_length); |
| EXPECT_NE( |
| 0, |
| std::memcmp(blank, state.data, hci_spec::kMaxLEAdvertisingDataLength)); |
| EXPECT_NE(0, state.scan_rsp_length); |
| } |
| |
| // stop advertising the random address |
| this->advertiser()->StopAdvertising(kPublicAddress); |
| this->RunUntilIdle(); |
| |
| // check that advertiser and controller both report the same advertising state |
| EXPECT_FALSE(this->advertiser()->IsAdvertising()); |
| EXPECT_FALSE(this->advertiser()->IsAdvertising(kPublicAddress)); |
| |
| { |
| const FakeController::LEAdvertisingState& state = |
| this->GetControllerAdvertisingState(); |
| EXPECT_FALSE(state.enabled); |
| EXPECT_EQ( |
| 0, |
| std::memcmp(blank, state.data, hci_spec::kMaxLEAdvertisingDataLength)); |
| EXPECT_EQ(0, state.data_length); |
| EXPECT_EQ( |
| 0, |
| std::memcmp(blank, state.data, hci_spec::kMaxLEAdvertisingDataLength)); |
| EXPECT_EQ(0, state.scan_rsp_length); |
| } |
| } |
| |
| // - Rejects anonymous advertisement (unsupported) |
| TYPED_TEST(LowEnergyAdvertiserTest, NoAnonymous) { |
| AdvertisingData ad = this->GetExampleData(); |
| AdvertisingData scan_data = this->GetExampleData(); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/true, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| ad, |
| scan_data, |
| options, |
| nullptr, |
| this->MakeExpectErrorCallback()); |
| EXPECT_TRUE(this->GetLastStatus()); |
| EXPECT_FALSE(this->GetControllerAdvertisingState().enabled); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, AdvertisingDataTooLong) { |
| AdvertisingData invalid_ad = |
| this->GetTooLargeExampleData(/*include_flags=*/true); |
| AdvertisingData valid_scan_rsp = |
| this->GetExampleData(/*include_flags=*/false); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| |
| // Advertising data too large. |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| invalid_ad, |
| valid_scan_rsp, |
| options, |
| nullptr, |
| this->MakeExpectErrorCallback()); |
| this->RunUntilIdle(); |
| auto status = this->GetLastStatus(); |
| ASSERT_TRUE(status); |
| EXPECT_EQ(ToResult(HostError::kAdvertisingDataTooLong), *status); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, AdvertisingDataTooLongWithTxPower) { |
| AdvertisingData invalid_ad = this->GetTooLargeExampleData( |
| /*include_flags=*/true, |
| hci_spec::kMaxLEAdvertisingDataLength - kTLVTxPowerLevelSize + 1); |
| AdvertisingData valid_scan_rsp = |
| this->GetExampleData(/*include_flags=*/false); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/true); |
| |
| // Advertising data too large. |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| invalid_ad, |
| valid_scan_rsp, |
| options, |
| nullptr, |
| this->MakeExpectErrorCallback()); |
| this->RunUntilIdle(); |
| auto status = this->GetLastStatus(); |
| ASSERT_TRUE(status); |
| EXPECT_EQ(ToResult(HostError::kAdvertisingDataTooLong), *status); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, ScanResponseTooLong) { |
| AdvertisingData valid_ad = this->GetExampleData(); |
| AdvertisingData invalid_scan_rsp = |
| this->GetTooLargeExampleData(/*include_flags=*/false); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/false); |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| valid_ad, |
| invalid_scan_rsp, |
| options, |
| nullptr, |
| this->MakeExpectErrorCallback()); |
| this->RunUntilIdle(); |
| auto status = this->GetLastStatus(); |
| ASSERT_TRUE(status); |
| EXPECT_EQ(ToResult(HostError::kScanResponseTooLong), *status); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, ScanResponseTooLongWithTxPower) { |
| AdvertisingData valid_ad = this->GetExampleData(); |
| AdvertisingData invalid_scan_rsp = this->GetTooLargeExampleData( |
| /*include_flags=*/false, |
| hci_spec::kMaxLEAdvertisingDataLength - kTLVTxPowerLevelSize + 1); |
| AdvertisingOptions options(kTestInterval, |
| /*anonymous=*/false, |
| kDefaultNoAdvFlags, |
| /*include_tx_power_level=*/true); |
| this->advertiser()->StartAdvertising(kRandomAddress, |
| valid_ad, |
| invalid_scan_rsp, |
| options, |
| nullptr, |
| this->MakeExpectErrorCallback()); |
| this->RunUntilIdle(); |
| auto status = this->GetLastStatus(); |
| ASSERT_TRUE(status); |
| EXPECT_EQ(ToResult(HostError::kScanResponseTooLong), *status); |
| } |
| |
| TYPED_TEST(LowEnergyAdvertiserTest, |
| DestroyingTransportBeforeAdvertiserDoesNotCrash) { |
| this->DeleteTransport(); |
| this->DestroyAdvertiser(); |
| } |
| |
| } // namespace |
| } // namespace bt::hci |
