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

Commit 16de5463 authored by Jack He's avatar Jack He
Browse files

HCI: Create AddressWithType and its unit tests 

* Create hci::AddressWithType that has both hci::Address and
  hci::AddressType in the same copyable, hashable, and comparable
  object for easier management
* Create unit tests for the hash function

Bug: 139135297
Test: bluetooth_test_gd.AddressWithTypeTest
Change-Id: I2c81de7a3bd19656b687ef498f02d6380321f92d
parent 231e3f20

system/gd/hci/Android.bp

+3 −2
Original line number Diff line number Diff line
@@ -17,10 +17,11 @@ filegroup { 
    srcs: [

        "acl_builder_test.cc",

        "acl_manager_test.cc",

        "classic_security_manager_test.cc",

        "controller_test.cc",

        "address_unittest.cc",

        "address_with_type_test.cc",

        "class_of_device_unittest.cc",

        "classic_security_manager_test.cc",

        "controller_test.cc",

        "device_test.cc",

        "device_database_test.cc",

        "dual_device_test.cc",

system/gd/hci/address_with_type.h

0 → 100644
+96 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright 2019 The Android Open Source Project

 *

 *  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.

 *

 ******************************************************************************/



#pragma once



#include <sstream>

#include <string>

#include <utility>



#include "hci/address.h"

#include "hci/hci_packets.h"



namespace bluetooth {

namespace hci {



class AddressWithType final {

 public:

  AddressWithType(Address address, AddressType address_type) : address_(address), address_type_(address_type) {}



  explicit AddressWithType() : address_(Address::kEmpty), address_type_(AddressType::PUBLIC_DEVICE_ADDRESS) {}



  inline Address GetAddress() const {

    return address_;

  }



  inline AddressType GetAddressType() const {

    return address_type_;

  }



  bool operator<(const AddressWithType& rhs) const {

    return address_ < rhs.address_ && address_type_ < rhs.address_type_;

  }

  bool operator==(const AddressWithType& rhs) const {

    return address_ == rhs.address_ && address_type_ == rhs.address_type_;

  }

  bool operator>(const AddressWithType& rhs) const {

    return (rhs < *this);

  }

  bool operator<=(const AddressWithType& rhs) const {

    return !(*this > rhs);

  }

  bool operator>=(const AddressWithType& rhs) const {

    return !(*this < rhs);

  }

  bool operator!=(const AddressWithType& rhs) const {

    return !(*this == rhs);

  }



  std::string ToString() const {

    std::stringstream ss;

    ss << address_ << "[" << AddressTypeText(address_type_) << "]";

    return ss.str();

  }



 private:

  Address address_;

  AddressType address_type_;

};



inline std::ostream& operator<<(std::ostream& os, const AddressWithType& a) {

  os << a.ToString();

  return os;

}



}  // namespace hci

}  // namespace bluetooth



namespace std {

template <>

struct hash<bluetooth::hci::AddressWithType> {

  std::size_t operator()(const bluetooth::hci::AddressWithType& val) const {

    static_assert(sizeof(uint64_t) >= (sizeof(bluetooth::hci::Address) + sizeof(bluetooth::hci::AddressType)));

    uint64_t int_addr = 0;

    memcpy(reinterpret_cast<uint8_t*>(&int_addr), val.GetAddress().address, sizeof(bluetooth::hci::Address));

    bluetooth::hci::AddressType address_type = val.GetAddressType();

    memcpy(reinterpret_cast<uint8_t*>(&int_addr) + sizeof(bluetooth::hci::Address), &address_type,

           sizeof(address_type));

    return std::hash<uint64_t>{}(int_addr);

  }

};

}  // namespace std
 
 No newline at end of file

system/gd/hci/address_with_type_test.cc

0 → 100644
+68 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright 2019 The Android Open Source Project

 *

 *  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 <unordered_map>



#include <gtest/gtest.h>



#include "hci/address.h"

#include "hci/address_with_type.h"

#include "hci/hci_packets.h"



namespace bluetooth {

namespace hci {



TEST(AddressWithTypeTest, AddressWithTypeSameValueSameOrder) {

  Address addr1{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};

  AddressType type1 = AddressType::PUBLIC_DEVICE_ADDRESS;

  AddressWithType address_with_type_1(addr1, type1);

  Address addr2{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};

  AddressType type2 = AddressType::PUBLIC_DEVICE_ADDRESS;

  AddressWithType address_with_type_2(addr2, type2);

  // Test if two address with type with same byte value have the same hash

  struct std::hash<bluetooth::hci::AddressWithType> hasher;

  EXPECT_EQ(hasher(address_with_type_1), hasher(address_with_type_2));

  // Test if two address with type with the same hash and the same value, they will

  // still map to the same value

  std::unordered_map<AddressWithType, int> data = {};

  data[address_with_type_1] = 5;

  data[address_with_type_2] = 8;

  EXPECT_EQ(data[address_with_type_1], data[address_with_type_2]);

}



TEST(AddressWithTypeTest, HashDifferentDiffAddrSameType) {

  Address addr{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};

  AddressType type = AddressType::PUBLIC_IDENTITY_ADDRESS;

  AddressWithType address_with_type(addr, type);

  struct std::hash<AddressWithType> hasher;

  EXPECT_NE(hasher(address_with_type), hasher(AddressWithType(Address::kEmpty, AddressType::PUBLIC_IDENTITY_ADDRESS)));

}



TEST(AddressWithTypeTest, HashDifferentSameAddressDiffType) {

  Address addr1{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};

  AddressType type1 = AddressType::PUBLIC_DEVICE_ADDRESS;

  AddressWithType address_with_type_1(addr1, type1);

  Address addr2{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}};

  AddressType type2 = AddressType::PUBLIC_IDENTITY_ADDRESS;

  AddressWithType address_with_type_2(addr2, type2);

  struct std::hash<bluetooth::hci::AddressWithType> hasher;

  EXPECT_NE(hasher(address_with_type_1), hasher(address_with_type_2));

}



}  // namespace hci

}  // namespace bluetooth
 
 No newline at end of file