mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-15 15:16:12 -04:00
721 lines
31 KiB
C++
721 lines
31 KiB
C++
// Copyright 2022 Google LLC
|
|
//
|
|
// 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 "fastpair/dataparser/fast_pair_data_parser.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <iterator>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "absl/strings/escaping.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "fastpair/common/constant.h"
|
|
#include "fastpair/common/non_discoverable_advertisement.h"
|
|
#include "fastpair/crypto/fast_pair_encryption.h"
|
|
#include "fastpair/testing/fast_pair_service_data_creator.h"
|
|
#include "internal/platform/count_down_latch.h"
|
|
|
|
namespace nearby {
|
|
namespace fastpair {
|
|
namespace {
|
|
// Test data comes from:
|
|
// https://developers.google.com/nearby/fast-pair/specifications/appendix/testcases#test_cases
|
|
|
|
constexpr absl::string_view kModelId("aabbcc");
|
|
constexpr absl::string_view kInvalidModelId("aabb");
|
|
constexpr absl::string_view kDeviceAddress("11:12:13:14:15:16");
|
|
constexpr absl::string_view kAccountKeyFilter("112233445566");
|
|
constexpr absl::string_view kSalt("01");
|
|
constexpr absl::string_view kBattery("01048F");
|
|
constexpr int kBatteryHeader = 0b00110011;
|
|
constexpr std::array<uint8_t, kAesBlockByteSize> kAeskeyarray = {
|
|
0xA0, 0xBA, 0xF0, 0xBB, 0x95, 0x1F, 0xF7, 0xB6,
|
|
0xCF, 0x5E, 0x3F, 0x45, 0x61, 0xC3, 0x32, 0x1D};
|
|
constexpr int kNotDiscoverableAdvHeader = 0b00000110;
|
|
constexpr int kAccountKeyFilterHeader = 0b01100000;
|
|
constexpr int kSaltHeader = 0b00010001;
|
|
|
|
TEST(FastPairDataParserTest, GetHexModelIdFromServiceDataUnsucessfully) {
|
|
const std::vector<uint8_t> service_data =
|
|
FastPairServiceDataCreator::Builder()
|
|
.SetModelId(kInvalidModelId)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::GetHexModelIdFromServiceData(
|
|
service_data, [&](std::optional<absl::string_view> model_id) {
|
|
EXPECT_EQ(model_id, std::nullopt);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, GetHexModelIdFromServiceDataSuccessfully) {
|
|
const std::vector<uint8_t> service_data =
|
|
FastPairServiceDataCreator::Builder()
|
|
.SetModelId(kModelId)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::GetHexModelIdFromServiceData(
|
|
service_data, [&](std::optional<absl::string_view> model_id) {
|
|
EXPECT_EQ(model_id, kModelId);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, DecryptResponseUnsuccessfullyWithInvalidAesKey) {
|
|
const std::vector<uint8_t> kAesKeyBytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95,
|
|
0x1F, 0xF7, 0xB6, 0xCF, 0x5E,
|
|
0x3F, 0x45, 0x61, 0xC3, 0x32};
|
|
|
|
const std::vector<uint8_t> kResponseBytes = {/*message_type=*/0x02,
|
|
/*address_bytes=*/0x02,
|
|
0x03,
|
|
0x04,
|
|
0x05,
|
|
0x06,
|
|
0x07,
|
|
/*salt=*/0x08,
|
|
0x09,
|
|
0x0A,
|
|
0x0B,
|
|
0x0C,
|
|
0x0D,
|
|
0x0E,
|
|
0x0F,
|
|
0x00};
|
|
|
|
std::array<uint8_t, kAesBlockByteSize> response_bytes_array;
|
|
std::copy(kResponseBytes.begin(), kResponseBytes.end(),
|
|
response_bytes_array.begin());
|
|
auto encrypted_bytes_array =
|
|
FastPairEncryption::EncryptBytes(kAeskeyarray, response_bytes_array);
|
|
std::vector<uint8_t> encrypted_bytes(encrypted_bytes_array.begin(),
|
|
encrypted_bytes_array.end());
|
|
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseDecryptedResponse(
|
|
kAesKeyBytes, encrypted_bytes,
|
|
[&](std::optional<DecryptedResponse> response) {
|
|
EXPECT_FALSE(response.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, DecryptResponseUnsuccessfullyWithInvalidResponse) {
|
|
const std::vector<uint8_t> kAesKeyBytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95, 0x1F,
|
|
0xF7, 0xB6, 0xCF, 0x5E, 0x3F, 0x45,
|
|
0x61, 0xC3, 0x32, 0x1D};
|
|
|
|
const std::vector<uint8_t> kResponseBytes = {/*message_type=*/0x02,
|
|
/*address_bytes=*/0x02,
|
|
0x03,
|
|
0x04,
|
|
0x05,
|
|
0x06,
|
|
0x07,
|
|
/*salt=*/0x08,
|
|
0x09,
|
|
0x0A,
|
|
0x0B,
|
|
0x0C,
|
|
0x0D,
|
|
0x0E,
|
|
0x0F,
|
|
0x00};
|
|
|
|
std::array<uint8_t, kAesBlockByteSize> response_bytes_array;
|
|
std::copy(kResponseBytes.begin(), kResponseBytes.end(),
|
|
response_bytes_array.begin());
|
|
auto encrypted_bytes_array =
|
|
FastPairEncryption::EncryptBytes(kAeskeyarray, response_bytes_array);
|
|
std::vector<uint8_t> encrypted_bytes(encrypted_bytes_array.begin(),
|
|
encrypted_bytes_array.end() - 1);
|
|
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseDecryptedResponse(
|
|
kAesKeyBytes, encrypted_bytes,
|
|
[&](std::optional<DecryptedResponse> response) {
|
|
EXPECT_FALSE(response.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, DecryptResponseSuccessfully) {
|
|
const std::vector<uint8_t> kAesKeyBytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95, 0x1F,
|
|
0xF7, 0xB6, 0xCF, 0x5E, 0x3F, 0x45,
|
|
0x61, 0xC3, 0x32, 0x1D};
|
|
std::vector<uint8_t> response_bytes;
|
|
|
|
// Message type.
|
|
constexpr uint8_t kMessageType = 0x01;
|
|
response_bytes.push_back(kMessageType);
|
|
|
|
// Address bytes.
|
|
constexpr std::array<uint8_t, 6> kAddressBytes = {0x02, 0x03, 0x04,
|
|
0x05, 0x06, 0x07};
|
|
std::copy(kAddressBytes.begin(), kAddressBytes.end(),
|
|
std::back_inserter(response_bytes));
|
|
|
|
// Random salt
|
|
constexpr std::array<uint8_t, 9> kSalt = {0x08, 0x09, 0x0A, 0x0B, 0x0C,
|
|
0x0D, 0x0E, 0x0F, 0x00};
|
|
std::copy(kSalt.begin(), kSalt.end(), std::back_inserter(response_bytes));
|
|
|
|
std::array<uint8_t, kAesBlockByteSize> response_bytes_array;
|
|
std::copy(response_bytes.begin(), response_bytes.end(),
|
|
response_bytes_array.begin());
|
|
auto encrypted_bytes_array =
|
|
FastPairEncryption::EncryptBytes(kAeskeyarray, response_bytes_array);
|
|
std::vector<uint8_t> encrypted_bytes(encrypted_bytes_array.begin(),
|
|
encrypted_bytes_array.end());
|
|
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseDecryptedResponse(
|
|
kAesKeyBytes, encrypted_bytes,
|
|
[&](std::optional<DecryptedResponse> response) {
|
|
ASSERT_TRUE(response.has_value());
|
|
EXPECT_EQ(response.value().message_type,
|
|
FastPairMessageType::kKeyBasedPairingResponse);
|
|
EXPECT_EQ(response.value().address_bytes, kAddressBytes);
|
|
EXPECT_EQ(response.value().salt, kSalt);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, DecryptPasskeyUnsuccessfullyWithInvalidAesKey) {
|
|
const std::vector<uint8_t> kAesKeyBytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95,
|
|
0x1F, 0xF7, 0xB6, 0xCF, 0x5E,
|
|
0x3F, 0x45, 0x61, 0xC3, 0x32};
|
|
|
|
const std::vector<uint8_t> kPasskeyBytes = {/*message_type=*/0x02,
|
|
/*address_bytes=*/0x02,
|
|
0x03,
|
|
0x04,
|
|
0x05,
|
|
0x06,
|
|
0x07,
|
|
/*salt=*/0x08,
|
|
0x09,
|
|
0x0A,
|
|
0x0B,
|
|
0x0C,
|
|
0x0D,
|
|
0x0E,
|
|
0x0F,
|
|
0x00};
|
|
|
|
std::array<uint8_t, kAesBlockByteSize> passkey_bytes_array;
|
|
std::copy(kPasskeyBytes.begin(), kPasskeyBytes.end(),
|
|
passkey_bytes_array.begin());
|
|
auto encrypted_bytes_array =
|
|
FastPairEncryption::EncryptBytes(kAeskeyarray, passkey_bytes_array);
|
|
std::vector<uint8_t> encrypted_bytes(encrypted_bytes_array.begin(),
|
|
encrypted_bytes_array.end());
|
|
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseDecryptedPasskey(
|
|
kAesKeyBytes, encrypted_bytes,
|
|
[&](std::optional<DecryptedPasskey> decrypted_passkey) {
|
|
EXPECT_FALSE(decrypted_passkey.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, DecryptPasskeyUnsuccessfullyWithInvalidPasskey) {
|
|
const std::vector<uint8_t> kAesKeyBytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95, 0x1F,
|
|
0xF7, 0xB6, 0xCF, 0x5E, 0x3F, 0x45,
|
|
0x61, 0xC3, 0x32, 0x1D};
|
|
|
|
const std::vector<uint8_t> kPasskeyBytes = {/*message_type=*/0x04,
|
|
/*passkey=*/0x02,
|
|
0x03,
|
|
0x04,
|
|
/*salt=*/0x05,
|
|
0x06,
|
|
0x07,
|
|
0x08,
|
|
0x09,
|
|
0x0A,
|
|
0x0B,
|
|
0x0C,
|
|
0x0D,
|
|
0x0E,
|
|
0x0F};
|
|
|
|
std::array<uint8_t, kAesBlockByteSize> passkey_bytes_array;
|
|
std::copy(kPasskeyBytes.begin(), kPasskeyBytes.end(),
|
|
passkey_bytes_array.begin());
|
|
auto encrypted_bytes_array =
|
|
FastPairEncryption::EncryptBytes(kAeskeyarray, passkey_bytes_array);
|
|
std::vector<uint8_t> encrypted_bytes(encrypted_bytes_array.begin(),
|
|
encrypted_bytes_array.end() - 1);
|
|
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseDecryptedPasskey(
|
|
kAesKeyBytes, encrypted_bytes,
|
|
[&](std::optional<DecryptedPasskey> decrypted_passkey) {
|
|
EXPECT_FALSE(decrypted_passkey.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, DecryptSeekerPasskeySuccessfully) {
|
|
const std::vector<uint8_t> kAesKeyBytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95, 0x1F,
|
|
0xF7, 0xB6, 0xCF, 0x5E, 0x3F, 0x45,
|
|
0x61, 0xC3, 0x32, 0x1D};
|
|
|
|
std::vector<uint8_t> passkey_bytes;
|
|
// Message type.
|
|
constexpr uint8_t kMessageType = 0x02;
|
|
passkey_bytes.push_back(kMessageType);
|
|
|
|
// Passkey bytes.
|
|
constexpr uint32_t kPasskey = 5;
|
|
passkey_bytes.push_back(kPasskey >> 16);
|
|
passkey_bytes.push_back(kPasskey >> 8);
|
|
passkey_bytes.push_back(kPasskey);
|
|
|
|
// Random salt
|
|
constexpr std::array<uint8_t, 12> kSalt = {
|
|
0x08, 0x09, 0x0A, 0x08, 0x09, 0x0E, 0x0A, 0x0C, 0x0D, 0x0E, 0x05, 0x02};
|
|
std::copy(kSalt.begin(), kSalt.end(), std::back_inserter(passkey_bytes));
|
|
std::array<uint8_t, kAesBlockByteSize> passkey_bytes_array;
|
|
std::copy(passkey_bytes.begin(), passkey_bytes.end(),
|
|
passkey_bytes_array.begin());
|
|
auto encrypted_bytes_array =
|
|
FastPairEncryption::EncryptBytes(kAeskeyarray, passkey_bytes_array);
|
|
std::vector<uint8_t> encrypted_bytes(encrypted_bytes_array.begin(),
|
|
encrypted_bytes_array.end());
|
|
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseDecryptedPasskey(
|
|
kAesKeyBytes, encrypted_bytes,
|
|
[&](std::optional<DecryptedPasskey> decrypted_passkey) {
|
|
ASSERT_TRUE(decrypted_passkey.has_value());
|
|
EXPECT_EQ(decrypted_passkey.value().message_type,
|
|
FastPairMessageType::kSeekersPasskey);
|
|
EXPECT_EQ(decrypted_passkey.value().passkey, kPasskey);
|
|
EXPECT_EQ(decrypted_passkey.value().salt, kSalt);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, DecryptProviderPasskeySuccessfully) {
|
|
const std::vector<uint8_t> kAesKeyBytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95, 0x1F,
|
|
0xF7, 0xB6, 0xCF, 0x5E, 0x3F, 0x45,
|
|
0x61, 0xC3, 0x32, 0x1D};
|
|
std::vector<uint8_t> passkey_bytes;
|
|
// Message type.
|
|
constexpr uint8_t kMessageType = 0x03;
|
|
passkey_bytes.push_back(kMessageType);
|
|
|
|
// Passkey bytes.
|
|
constexpr uint32_t kPasskey = 5;
|
|
passkey_bytes.push_back(kPasskey >> 16);
|
|
passkey_bytes.push_back(kPasskey >> 8);
|
|
passkey_bytes.push_back(kPasskey);
|
|
|
|
// Random salt
|
|
constexpr std::array<uint8_t, 12> kSalt = {
|
|
0x08, 0x09, 0x0A, 0x08, 0x09, 0x0E, 0x0A, 0x0C, 0x0D, 0x0E, 0x05, 0x02};
|
|
std::copy(kSalt.begin(), kSalt.end(), std::back_inserter(passkey_bytes));
|
|
|
|
std::array<uint8_t, kAesBlockByteSize> passkey_bytes_array;
|
|
std::copy(passkey_bytes.begin(), passkey_bytes.end(),
|
|
passkey_bytes_array.begin());
|
|
auto encrypted_bytes_array =
|
|
FastPairEncryption::EncryptBytes(kAeskeyarray, passkey_bytes_array);
|
|
std::vector<uint8_t> encrypted_bytes(encrypted_bytes_array.begin(),
|
|
encrypted_bytes_array.end());
|
|
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseDecryptedPasskey(
|
|
kAesKeyBytes, encrypted_bytes,
|
|
[&](std::optional<DecryptedPasskey> decrypted_passkey) {
|
|
ASSERT_TRUE(decrypted_passkey.has_value());
|
|
EXPECT_EQ(decrypted_passkey.value().message_type,
|
|
FastPairMessageType::kProvidersPasskey);
|
|
EXPECT_EQ(decrypted_passkey.value().passkey, kPasskey);
|
|
EXPECT_EQ(decrypted_passkey.value().salt, kSalt);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementEmpty) {
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
"", kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
EXPECT_FALSE(advertisement.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest,
|
|
ParseNotDiscoverableAdvertisementNoApplicibleData) {
|
|
std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
EXPECT_FALSE(advertisement.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest,
|
|
ParseNotDiscoverableAdvertisementAccountKeyFilter) {
|
|
const std::vector<uint8_t> kSaltBytes = {0x01};
|
|
std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(kAccountKeyFilterHeader)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(kSaltHeader)
|
|
.AddExtraField(kSalt)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
ASSERT_TRUE(advertisement.has_value());
|
|
EXPECT_EQ(absl::BytesToHexString(
|
|
std::string(advertisement->account_key_filter.begin(),
|
|
advertisement->account_key_filter.end())),
|
|
kAccountKeyFilter);
|
|
EXPECT_EQ(advertisement->salt, kSaltBytes);
|
|
EXPECT_EQ(advertisement->type,
|
|
NonDiscoverableAdvertisement::Type::kShowUi);
|
|
EXPECT_FALSE(advertisement->battery_notification.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest,
|
|
ParseNotDiscoverableAdvertisementAccountKeyFilterNoNotification) {
|
|
const std::vector<uint8_t> kSaltBytes = {0x01};
|
|
std::vector<uint8_t> bytes =
|
|
FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(
|
|
/*accountKeyFilterNoNotificationHeader*/ 0b01100010)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(kSaltHeader)
|
|
.AddExtraField(kSalt)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
ASSERT_TRUE(advertisement.has_value());
|
|
EXPECT_EQ(absl::BytesToHexString(
|
|
std::string(advertisement->account_key_filter.begin(),
|
|
advertisement->account_key_filter.end())),
|
|
kAccountKeyFilter);
|
|
EXPECT_EQ(advertisement->salt, kSaltBytes);
|
|
EXPECT_EQ(advertisement->type,
|
|
NonDiscoverableAdvertisement::Type::kHideUi);
|
|
EXPECT_FALSE(advertisement->battery_notification.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementWrongVersion) {
|
|
std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
|
|
.SetHeader(/*InvalidHeader*/ 0b00100000)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
EXPECT_FALSE(advertisement.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest,
|
|
ParseNotDiscoverableAdvertisementZeroLengthExtraField) {
|
|
std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(kAccountKeyFilterHeader)
|
|
.AddExtraField("")
|
|
.AddExtraFieldHeader(kSaltHeader)
|
|
.AddExtraField(kSalt)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
EXPECT_FALSE(advertisement.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementWrongType) {
|
|
std::vector<uint8_t> bytes =
|
|
FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader /*InvalidType*/ (0b01100001)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(kSaltHeader)
|
|
.AddExtraField(kSalt)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
EXPECT_FALSE(advertisement.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementSaltTwoBytes) {
|
|
const std::vector<uint8_t> kLargeSaltBytes = {0xC7, 0xC8};
|
|
std::vector<uint8_t> bytes =
|
|
FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(kAccountKeyFilterHeader)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(/*SaltTwoBytes*/ 0b00100001)
|
|
.AddExtraField(/*LargeSalt*/ "C7C8")
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
ASSERT_TRUE(advertisement.has_value());
|
|
EXPECT_EQ(absl::BytesToHexString(
|
|
std::string(advertisement->account_key_filter.begin(),
|
|
advertisement->account_key_filter.end())),
|
|
kAccountKeyFilter);
|
|
EXPECT_EQ(advertisement->salt, kLargeSaltBytes);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementSaltTooLarge) {
|
|
std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(kAccountKeyFilterHeader)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(0b00110001)
|
|
.AddExtraField(/*invalidSalt*/ "C7C8C9")
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
EXPECT_FALSE(advertisement.has_value());
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementWithBattery) {
|
|
const std::vector<uint8_t> kSaltBytes = {0x01};
|
|
std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(kAccountKeyFilterHeader)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(kSaltHeader)
|
|
.AddExtraField(kSalt)
|
|
.AddExtraFieldHeader(kBatteryHeader)
|
|
.AddExtraField(kBattery)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
ASSERT_TRUE(advertisement.has_value());
|
|
EXPECT_EQ(absl::BytesToHexString(
|
|
std::string(advertisement->account_key_filter.begin(),
|
|
advertisement->account_key_filter.end())),
|
|
kAccountKeyFilter);
|
|
EXPECT_EQ(advertisement->salt, kSaltBytes);
|
|
EXPECT_EQ(advertisement->type,
|
|
NonDiscoverableAdvertisement::Type::kShowUi);
|
|
ASSERT_TRUE(advertisement->battery_notification.has_value());
|
|
EXPECT_EQ(advertisement->battery_notification->type,
|
|
BatteryNotification::Type::kShowUi);
|
|
EXPECT_FALSE(advertisement->battery_notification->battery_infos.at(0)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(0).percentage,
|
|
1);
|
|
EXPECT_FALSE(advertisement->battery_notification->battery_infos.at(1)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(1).percentage,
|
|
4);
|
|
ASSERT_TRUE(advertisement->battery_notification->battery_infos.at(2)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(2).percentage,
|
|
15);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementMissingSalt) {
|
|
const std::vector<uint8_t> kDeviceAddressBytes = {17, 18, 19, 20, 21, 22};
|
|
std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(kAccountKeyFilterHeader)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(kBatteryHeader)
|
|
.AddExtraField(kBattery)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
ASSERT_TRUE(advertisement.has_value());
|
|
EXPECT_EQ(absl::BytesToHexString(
|
|
std::string(advertisement->account_key_filter.begin(),
|
|
advertisement->account_key_filter.end())),
|
|
kAccountKeyFilter);
|
|
EXPECT_EQ(advertisement->salt, kDeviceAddressBytes);
|
|
EXPECT_EQ(advertisement->type,
|
|
NonDiscoverableAdvertisement::Type::kShowUi);
|
|
ASSERT_TRUE(advertisement->battery_notification.has_value());
|
|
EXPECT_EQ(advertisement->battery_notification->type,
|
|
BatteryNotification::Type::kShowUi);
|
|
EXPECT_FALSE(advertisement->battery_notification->battery_infos.at(0)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(0).percentage,
|
|
1);
|
|
EXPECT_FALSE(advertisement->battery_notification->battery_infos.at(1)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(1).percentage,
|
|
4);
|
|
ASSERT_TRUE(advertisement->battery_notification->battery_infos.at(2)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(2).percentage,
|
|
15);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
TEST(FastPairDataParserTest, ParseNotDiscoverableAdvertisementWithBatteryNoUi) {
|
|
const std::vector<uint8_t> kSaltBytes = {0x01};
|
|
std::vector<uint8_t> bytes =
|
|
FastPairServiceDataCreator::Builder()
|
|
.SetHeader(kNotDiscoverableAdvHeader)
|
|
.SetModelId(kModelId)
|
|
.AddExtraFieldHeader(kAccountKeyFilterHeader)
|
|
.AddExtraField(kAccountKeyFilter)
|
|
.AddExtraFieldHeader(kSaltHeader)
|
|
.AddExtraField(kSalt)
|
|
.AddExtraFieldHeader(/*batterHeaderNoNotification*/ 0b00110100)
|
|
.AddExtraField(kBattery)
|
|
.Build()
|
|
->CreateServiceData();
|
|
CountDownLatch latch(1);
|
|
|
|
FastPairDataParser::ParseNotDiscoverableAdvertisement(
|
|
std::string(bytes.begin(), bytes.end()), kDeviceAddress,
|
|
[&](const std::optional<NonDiscoverableAdvertisement> advertisement) {
|
|
ASSERT_TRUE(advertisement.has_value());
|
|
EXPECT_EQ(absl::BytesToHexString(
|
|
std::string(advertisement->account_key_filter.begin(),
|
|
advertisement->account_key_filter.end())),
|
|
kAccountKeyFilter);
|
|
EXPECT_EQ(advertisement->salt, kSaltBytes);
|
|
EXPECT_EQ(advertisement->type,
|
|
NonDiscoverableAdvertisement::Type::kShowUi);
|
|
ASSERT_TRUE(advertisement->battery_notification.has_value());
|
|
EXPECT_EQ(advertisement->battery_notification->type,
|
|
BatteryNotification::Type::kHideUi);
|
|
EXPECT_FALSE(advertisement->battery_notification->battery_infos.at(0)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(0).percentage,
|
|
1);
|
|
EXPECT_FALSE(advertisement->battery_notification->battery_infos.at(1)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(1).percentage,
|
|
4);
|
|
ASSERT_TRUE(advertisement->battery_notification->battery_infos.at(2)
|
|
.is_charging);
|
|
EXPECT_EQ(
|
|
advertisement->battery_notification->battery_infos.at(2).percentage,
|
|
15);
|
|
latch.CountDown();
|
|
});
|
|
latch.Await();
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace fastpair
|
|
} // namespace nearby
|