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

Commit b1fc1f85 authored by Chris Manton's avatar Chris Manton Committed by Automerger Merge Worker
Browse files

Merge "Introduce shim ble_scanning/advertising test" am: ebacf381 am: 184bda5a 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/1980807

Change-Id: Ia3f45dc4e1567f6e974d91f6817db211c560380d
parents b318c636 184bda5a

system/main/test/main_shim_test.cc

+100 −0
Original line number Diff line number Diff line
@@ -24,18 +24,36 @@ 
#include "btaa/activity_attribution.h"

#include "btif/include/btif_hh.h"

#include "device/include/controller.h"

#include "hal/hci_hal.h"

#include "hci/acl_manager.h"

#include "hci/acl_manager/classic_acl_connection.h"

#include "hci/acl_manager/connection_callbacks.h"

#include "hci/acl_manager/connection_management_callbacks.h"

#include "hci/acl_manager/le_acl_connection.h"

#include "hci/acl_manager/le_connection_callbacks.h"

#include "hci/acl_manager/le_connection_management_callbacks.h"

#include "hci/acl_manager_mock.h"

#include "hci/controller_mock.h"

#include "hci/le_advertising_manager_mock.h"

#include "hci/le_scanning_manager_mock.h"

#include "include/hardware/ble_scanner.h"

#include "include/hardware/bt_activity_attribution.h"

#include "main/shim/acl.h"

#include "main/shim/acl_legacy_interface.h"

#include "main/shim/ble_scanner_interface_impl.h"

#include "main/shim/helpers.h"

#include "main/shim/le_advertising_manager.h"

#include "main/shim/le_scanning_manager.h"

#include "os/handler.h"

#include "os/mock_queue.h"

#include "os/queue.h"

#include "os/thread.h"

#include "packet/packet_view.h"

#include "stack/btm/btm_int_types.h"

#include "stack/include/bt_hdr.h"

#include "stack/include/hci_error_code.h"

#include "stack/l2cap/l2c_int.h"

#include "test/common/jni_thread.h"

#include "test/common/main_handler.h"

#include "test/common/mock_functions.h"

#include "test/mock/mock_main_shim_entry.h"
@@ -43,6 +61,8 @@ 
#include "types/hci_role.h"

#include "types/raw_address.h"



using ::testing::_;



using namespace bluetooth;

using namespace testing;
@@ -55,6 +75,9 @@ tL2C_CB l2cb; 
tBTM_CB btm_cb;

btif_hh_cb_t btif_hh_cb;



struct bluetooth::hci::LeScanningManager::impl

    : public bluetooth::hci::LeAddressManagerCallback {};



namespace {

std::map<std::string, std::promise<uint16_t>> mock_function_handle_promise_map;

}
@@ -160,6 +183,8 @@ const shim::legacy::acl_interface_t GetMockAclInterface() { 


struct hci_packet_parser_t;

const hci_packet_parser_t* hci_packet_parser_get_interface() { return nullptr; }

struct hci_t;

const hci_t* hci_layer_get_interface() { return nullptr; }

struct packet_fragmenter_t;

const packet_fragmenter_t* packet_fragmenter_get_interface() { return nullptr; }

void LogMsg(uint32_t trace_set_mask, const char* fmt_str, ...) {}
@@ -256,6 +281,8 @@ class MainShimTest : public testing::Test { 
 public:

 protected:

  void SetUp() override {

    reset_mock_function_count_map();



    main_thread_start_up();



    thread_ = new os::Thread("acl_thread", os::Thread::Priority::NORMAL);
@@ -265,12 +292,20 @@ class MainShimTest : public testing::Test { 
        new bluetooth::hci::testing::MockController();

    /* extern */ test::mock_acl_manager_ =

        new bluetooth::hci::testing::MockAclManager();

    /* extern */ test::mock_le_scanning_manager_ =

        new bluetooth::hci::testing::MockLeScanningManager();

    /* extern */ test::mock_le_advertising_manager_ =

        new bluetooth::hci::testing::MockLeAdvertisingManager();

  }

  void TearDown() override {

    delete test::mock_controller_;

    test::mock_controller_ = nullptr;

    delete test::mock_acl_manager_;

    test::mock_acl_manager_ = nullptr;

    delete test::mock_le_advertising_manager_;

    test::mock_le_advertising_manager_ = nullptr;

    delete test::mock_le_scanning_manager_;

    test::mock_le_scanning_manager_ = nullptr;



    handler_->Clear();

    delete handler_;
@@ -361,6 +396,8 @@ TEST_F(MainShimTest, connect_and_disconnect) { 
  handler_->Call([](std::promise<void> done) { done.set_value(); },

                 std::move(done));

  future.wait();



  connection.reset();

}



TEST_F(MainShimTest, is_flushable) {
@@ -403,3 +440,66 @@ TEST_F(MainShimTest, is_flushable) { 
    ASSERT_TRUE(IsPacketFlushable(bt_hdr));

  }

}



TEST_F(MainShimTest, BleScannerInterfaceImpl_nop) {

  auto* ble = static_cast<bluetooth::shim::BleScannerInterfaceImpl*>(

      bluetooth::shim::get_ble_scanner_instance());

  ASSERT_NE(nullptr, ble);

}



class TestScanningCallbacks : public ::ScanningCallbacks {

 public:

  ~TestScanningCallbacks() {}

  void OnScannerRegistered(const bluetooth::Uuid app_uuid, uint8_t scannerId,

                           uint8_t status) override {}

  void OnSetScannerParameterComplete(uint8_t scannerId,

                                     uint8_t status) override {}

  void OnScanResult(uint16_t event_type, uint8_t addr_type, RawAddress bda,

                    uint8_t primary_phy, uint8_t secondary_phy,

                    uint8_t advertising_sid, int8_t tx_power, int8_t rssi,

                    uint16_t periodic_adv_int,

                    std::vector<uint8_t> adv_data) override {}

  void OnTrackAdvFoundLost(

      AdvertisingTrackInfo advertising_track_info) override {}

  void OnBatchScanReports(int client_if, int status, int report_format,

                          int num_records, std::vector<uint8_t> data) override {

  }

  void OnBatchScanThresholdCrossed(int client_if) override {}

};



TEST_F(MainShimTest, BleScannerInterfaceImpl_OnScanResult) {

  auto* ble = static_cast<bluetooth::shim::BleScannerInterfaceImpl*>(

      bluetooth::shim::get_ble_scanner_instance());



  EXPECT_CALL(*hci::testing::mock_le_scanning_manager_,

              RegisterScanningCallback(_))

      .Times(1);

  ;

  bluetooth::shim::init_scanning_manager();



  TestScanningCallbacks cb;

  ble->RegisterCallbacks(&cb);



  //  Simulate scan results from the lower layers

  for (int i = 0; i < 2048; i++) {

    uint16_t event_type = 0;

    uint8_t address_type = BLE_ADDR_ANONYMOUS;

    bluetooth::hci::Address address;

    uint8_t primary_phy = 0;

    uint8_t secondary_phy = 0;

    uint8_t advertising_sid = 0;

    int8_t tx_power = 0;

    int8_t rssi = 0;

    uint16_t periodic_advertising_interval = 0;

    std::vector<uint8_t> advertising_data;



    ble->OnScanResult(event_type, address_type, address, primary_phy,

                      secondary_phy, advertising_sid, tx_power, rssi,

                      periodic_advertising_interval, advertising_data);

  }



  ASSERT_EQ(2 * 2048UL, do_in_jni_thread_task_queue.size());

  ASSERT_EQ(0, mock_function_count_map["btm_ble_process_adv_addr"]);



  run_all_jni_thread_task();

}

system/test/mock/mock_main_shim_entry.cc

+10 −7
Original line number Diff line number Diff line
@@ -14,14 +14,11 @@ 
 * limitations under the License.

 */



// #include "gd/btaa/activity_attribution.h"

#include "gd/module.h"



#include "gd/hci/acl_manager_mock.h"

#include "gd/hci/controller_mock.h"

#include "gd/hci/hci_layer.h"

#include "gd/hci/le_advertising_manager.h"

#include "gd/hci/le_scanning_manager.h"

#include "gd/hci/le_advertising_manager_mock.h"

#include "gd/hci/le_scanning_manager_mock.h"

#include "gd/neighbor/connectability.h"

#include "gd/neighbor/discoverability.h"

#include "gd/neighbor/inquiry.h"
@@ -41,6 +38,8 @@ namespace testing { 
MockAclManager* mock_acl_manager_{nullptr};

MockController* mock_controller_{nullptr};

os::Handler* mock_gd_shim_handler_{nullptr};

MockLeAdvertisingManager* mock_le_advertising_manager_{nullptr};

MockLeScanningManager* mock_le_scanning_manager_{nullptr};



}  // namespace testing

}  // namespace hci
@@ -56,8 +55,12 @@ activity_attribution::ActivityAttribution* GetActivityAttribution() { 
hci::AclManager* GetAclManager() { return hci::testing::mock_acl_manager_; }

hci::Controller* GetController() { return hci::testing::mock_controller_; }

hci::HciLayer* GetHciLayer() { return nullptr; }

hci::LeAdvertisingManager* GetAdvertising() { return nullptr; }

hci::LeScanningManager* GetScanning() { return nullptr; }

hci::LeAdvertisingManager* GetAdvertising() {

  return hci::testing::mock_le_advertising_manager_;

}

hci::LeScanningManager* GetScanning() {

  return hci::testing::mock_le_scanning_manager_;

}

hci::VendorSpecificEventManager* GetVendorSpecificEventManager() {

  return nullptr;

}

system/test/mock/mock_main_shim_entry.h

+7 −0
Original line number Diff line number Diff line
@@ -14,12 +14,19 @@ 
 * limitations under the License.

 */



#include "hci/acl_manager_mock.h"

#include "hci/controller_mock.h"

#include "hci/le_advertising_manager_mock.h"

#include "hci/le_scanning_manager_mock.h"



namespace bluetooth {

namespace hci {

namespace testing {



extern MockAclManager* mock_acl_manager_;

extern MockController* mock_controller_;

extern MockLeAdvertisingManager* mock_le_advertising_manager_;

extern MockLeScanningManager* mock_le_scanning_manager_;



}  // namespace testing

}  // namespace hci