You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
255 lines
9.9 KiB
255 lines
9.9 KiB
// |
|
// Copyright 2016 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 <cutils/properties.h> |
|
#include <errno.h> |
|
#include <fcntl.h> |
|
#include <gtest/gtest.h> |
|
|
|
#include <string> |
|
#include <vector> |
|
using std::vector; |
|
|
|
#include "bluetooth_address.h" |
|
|
|
namespace android { |
|
namespace hardware { |
|
namespace bluetooth { |
|
namespace V1_0 { |
|
namespace implementation { |
|
|
|
constexpr char kTestAddr1[BluetoothAddress::kStringLength + 1] = |
|
"12:34:56:78:9a:bc"; |
|
constexpr uint8_t kTestAddr1_bytes[BluetoothAddress::kBytes] = { |
|
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}; |
|
constexpr char kZeros[BluetoothAddress::kStringLength + 1] = |
|
"00:00:00:00:00:00"; |
|
constexpr uint8_t kZeros_bytes[BluetoothAddress::kBytes] = {0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00}; |
|
constexpr char kTestAddrBad1[BluetoothAddress::kStringLength + 1] = |
|
"bb:aa:dd:00:00:01"; |
|
constexpr uint8_t kTestAddrBad1_bytes[BluetoothAddress::kBytes] = { |
|
0xbb, 0xaa, 0xdd, 0x00, 0x00, 0x01}; |
|
|
|
constexpr char kAddrPath[] = "/tmp/my_address_in_a_file.txt"; |
|
|
|
class BluetoothAddressTest : public ::testing::Test { |
|
public: |
|
BluetoothAddressTest() {} |
|
~BluetoothAddressTest() {} |
|
|
|
void FileWriteString(const char* path, const char* string); |
|
}; |
|
|
|
void BluetoothAddressTest::FileWriteString(const char* path, |
|
const char* string) { |
|
int fd = open(path, O_CREAT | O_RDWR); |
|
EXPECT_TRUE(fd > 0) << "err = " << strerror(errno); |
|
|
|
size_t length = strlen(string); |
|
size_t bytes_written = write(fd, string, length); |
|
|
|
EXPECT_EQ(length, bytes_written) << strerror(errno); |
|
|
|
close(fd); |
|
} |
|
|
|
TEST_F(BluetoothAddressTest, string_to_bytes) { |
|
uint8_t addr[BluetoothAddress::kBytes]; |
|
|
|
// Malformed addresses |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("000000000000", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:0000", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:00:0", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:00:0;", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("aB:cD:eF:Gh:iJ:Kl", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:000:00:00:0;", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("12:34:56:78:90:12;", addr)); |
|
EXPECT_FALSE(BluetoothAddress::string_to_bytes("12:34:56:78:90:123", addr)); |
|
|
|
// Reasonable addresses |
|
EXPECT_TRUE(BluetoothAddress::string_to_bytes("00:00:00:00:00:00", addr)); |
|
EXPECT_TRUE(BluetoothAddress::string_to_bytes("a5:a5:a5:a5:a5:a5", addr)); |
|
EXPECT_TRUE(BluetoothAddress::string_to_bytes("5A:5A:5A:5A:5A:5A", addr)); |
|
EXPECT_TRUE(BluetoothAddress::string_to_bytes("AA:BB:CC:DD:EE:FF", addr)); |
|
EXPECT_TRUE(BluetoothAddress::string_to_bytes("aa:bb:cc:dd:ee:ff", addr)); |
|
|
|
// Compare the output to known bytes |
|
uint8_t addrA[BluetoothAddress::kBytes]; |
|
uint8_t addrB[BluetoothAddress::kBytes]; |
|
|
|
// kTestAddr1 |
|
EXPECT_TRUE(BluetoothAddress::string_to_bytes(kTestAddr1, addrA)); |
|
EXPECT_TRUE(memcmp(addrA, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0); |
|
|
|
// kZeros |
|
EXPECT_TRUE(BluetoothAddress::string_to_bytes(kZeros, addrB)); |
|
EXPECT_TRUE(memcmp(addrB, kZeros_bytes, BluetoothAddress::kBytes) == 0); |
|
|
|
// kTestAddr1 != kZeros |
|
EXPECT_FALSE(memcmp(addrA, addrB, BluetoothAddress::kBytes) == 0); |
|
} |
|
|
|
TEST_F(BluetoothAddressTest, bytes_to_string) { |
|
char addrA[BluetoothAddress::kStringLength + 1] = ""; |
|
char addrB[BluetoothAddress::kStringLength + 1] = ""; |
|
|
|
// kTestAddr1 |
|
BluetoothAddress::bytes_to_string(kTestAddr1_bytes, addrA); |
|
EXPECT_TRUE(memcmp(addrA, kTestAddr1, BluetoothAddress::kStringLength) == 0); |
|
|
|
// kZeros |
|
BluetoothAddress::bytes_to_string(kZeros_bytes, addrB); |
|
EXPECT_TRUE(memcmp(addrB, kZeros, BluetoothAddress::kStringLength) == 0); |
|
|
|
// kTestAddr1 != kZeros |
|
EXPECT_FALSE(memcmp(addrA, addrB, BluetoothAddress::kStringLength) == 0); |
|
} |
|
|
|
TEST_F(BluetoothAddressTest, property_set) { |
|
// Set the properties to empty strings. |
|
property_set(PERSIST_BDADDR_PROPERTY, ""); |
|
property_set(PROPERTY_BT_BDADDR_PATH, ""); |
|
property_set(FACTORY_BDADDR_PROPERTY, ""); |
|
|
|
// Get returns 0. |
|
char prop[PROP_VALUE_MAX] = ""; |
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 0); |
|
EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 0); |
|
EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 0); |
|
|
|
// Set the properties to known strings. |
|
property_set(PERSIST_BDADDR_PROPERTY, "1"); |
|
property_set(PROPERTY_BT_BDADDR_PATH, "22"); |
|
property_set(FACTORY_BDADDR_PROPERTY, "333"); |
|
|
|
// Get returns the correct length. |
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 1); |
|
EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 2); |
|
EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 3); |
|
|
|
// Set the properties to empty strings again. |
|
property_set(PERSIST_BDADDR_PROPERTY, ""); |
|
property_set(PROPERTY_BT_BDADDR_PATH, ""); |
|
property_set(FACTORY_BDADDR_PROPERTY, ""); |
|
|
|
// Get returns 0. |
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 0); |
|
EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 0); |
|
EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 0); |
|
} |
|
|
|
TEST_F(BluetoothAddressTest, property_get) { |
|
// Set the properties to known strings. |
|
property_set(PERSIST_BDADDR_PROPERTY, PERSIST_BDADDR_PROPERTY); |
|
property_set(PROPERTY_BT_BDADDR_PATH, PROPERTY_BT_BDADDR_PATH); |
|
property_set(FACTORY_BDADDR_PROPERTY, FACTORY_BDADDR_PROPERTY); |
|
|
|
// Get returns the same strings. |
|
char prop[PROP_VALUE_MAX] = ""; |
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(PERSIST_BDADDR_PROPERTY, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(PROPERTY_BT_BDADDR_PATH, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0); |
|
|
|
// Set a property to a different known string. |
|
char prop2[PROP_VALUE_MAX] = "Erased"; |
|
property_set(PERSIST_BDADDR_PROPERTY, prop2); |
|
|
|
// Get returns the correct strings. |
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(prop2, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(PROPERTY_BT_BDADDR_PATH, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0); |
|
|
|
// Set another property to prop2. |
|
property_set(PROPERTY_BT_BDADDR_PATH, prop2); |
|
|
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(prop2, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(prop2, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0); |
|
|
|
// Set the third property to prop2. |
|
property_set(FACTORY_BDADDR_PROPERTY, prop2); |
|
|
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(prop2, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(prop2, prop) == 0); |
|
|
|
EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0); |
|
EXPECT_TRUE(strcmp(prop2, prop) == 0); |
|
} |
|
|
|
TEST_F(BluetoothAddressTest, get_local_address) { |
|
EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, "") == 0); |
|
EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, "") == 0); |
|
uint8_t address[BluetoothAddress::kBytes]; |
|
|
|
// File contains a non-zero Address. |
|
FileWriteString(kAddrPath, kTestAddr1); |
|
EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, kAddrPath) == 0); |
|
EXPECT_TRUE(BluetoothAddress::get_local_address(address)); |
|
EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0); |
|
|
|
// File contains a zero address. A random address will be generated. |
|
FileWriteString(kAddrPath, kZeros); |
|
EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, kAddrPath) == 0); |
|
EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddrBad1) == 0); |
|
EXPECT_TRUE(BluetoothAddress::get_local_address(address)); |
|
EXPECT_TRUE(memcmp(address, kZeros_bytes, BluetoothAddress::kBytes) != 0); |
|
char prop[PROP_VALUE_MAX] = "Before reading"; |
|
EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == |
|
BluetoothAddress::kStringLength); |
|
char address_str[BluetoothAddress::kStringLength + 1]; |
|
BluetoothAddress::bytes_to_string(address, address_str); |
|
EXPECT_TRUE(memcmp(address_str, prop, BluetoothAddress::kStringLength) == 0); |
|
|
|
// Factory property contains an address. |
|
EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddrBad1) == 0); |
|
EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, kTestAddr1) == 0); |
|
EXPECT_TRUE(BluetoothAddress::get_local_address(address)); |
|
EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0); |
|
|
|
// Persistent property contains an address. |
|
memcpy(address, kTestAddrBad1_bytes, BluetoothAddress::kBytes); |
|
EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddr1) == 0); |
|
EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, "") == 0); |
|
EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, "") == 0); |
|
EXPECT_TRUE(BluetoothAddress::get_local_address(address)); |
|
EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0); |
|
} |
|
|
|
} // namespace implementation |
|
} // namespace V1_0 |
|
} // namespace bluetooth |
|
} // namespace hardware |
|
} // namespace android
|
|
|