TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-16 15:36:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

[BLE Refactor] Add Base64 encoder to BleAdvertisementHeader

Browse Source 
PiperOrigin-RevId: 453567012
This commit is contained in:
edwinwu
2022-06-07 17:59:33 -07:00
committed by Copybara-Service
parent 199bbc9cd1
commit 9069451c08
2 changed files with 62 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
connections/implementation/mediums/ble_v2/ble_advertisement_header.cc
+8 -6
View File
@@ -20,6 +20,7 @@
#include <utility>
#include "absl/strings/str_cat.h"
#include "internal/platform/base64_utils.h"
#include "internal/platform/base_input_stream.h"
#include "internal/platform/logging.h"
@@ -54,24 +55,25 @@ BleAdvertisementHeader::BleAdvertisementHeader(
BleAdvertisementHeader::BleAdvertisementHeader(
const ByteArray &ble_advertisement_header_bytes) {
if (ble_advertisement_header_bytes.Empty()) {
ByteArray advertisement_header_bytes =
Base64Utils::Decode(ble_advertisement_header_bytes.AsStringView());
if (advertisement_header_bytes.Empty()) {
NEARBY_LOG(
ERROR,
"Cannot deserialize BLEAdvertisementHeader: failed Base64 decoding");
return;
}
if (ble_advertisement_header_bytes.size() < kMinAdvertisementHeaderLength) {
if (advertisement_header_bytes.size() < kMinAdvertisementHeaderLength) {
NEARBY_LOG(ERROR,
"Cannot deserialize BleAdvertisementHeader: expecting min %u "
"raw bytes, got %" PRIu64 " instead",
kMinAdvertisementHeaderLength,
ble_advertisement_header_bytes.size());
advertisement_header_bytes.size());
return;
}
ByteArray advertisement_header_bytes{ble_advertisement_header_bytes};
BaseInputStream base_input_stream{advertisement_header_bytes};
BaseInputStream base_input_stream(advertisement_header_bytes);
// The first 1 byte is supposed to be the version and number of slots.
auto version_and_num_slots_byte =
static_cast<char>(base_input_stream.ReadUint8());
@@ -138,7 +140,7 @@ BleAdvertisementHeader::operator ByteArray() const {
std::string(psm_bytes));
// clang-format on
return ByteArray(std::move(out));
return ByteArray(Base64Utils::Encode(ByteArray(std::move(out))));
}
bool BleAdvertisementHeader::operator==(
connections/implementation/mediums/ble_v2/ble_advertisement_header_test.cc
+54 -86
View File
@@ -18,6 +18,7 @@
#include "gtest/gtest.h"
#include "absl/hash/hash_testing.h"
#include "internal/platform/base64_utils.h"
namespace location {
namespace nearby {
@@ -34,12 +35,12 @@ constexpr absl::string_view kServiceIDBloomFilter{
constexpr absl::string_view kAdvertisementHash{"\x0a\x0b\x0c\x0d"};
TEST(BleAdvertisementHeaderTest, ConstructionWorks) {
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
BleAdvertisementHeader ble_advertisement_header(
kVersion, false, kNumSlots, service_id_bloom_filter, advertisement_hash,
kPsmValue);
EXPECT_TRUE(ble_advertisement_header.IsValid());
EXPECT_EQ(kVersion, ble_advertisement_header.GetVersion());
@@ -55,12 +56,11 @@ TEST(BleAdvertisementHeaderTest, ConstructionWorks) {
TEST(BleAdvertisementHeaderTest, ConstructionFailsWithBadVersion) {
auto bad_version = static_cast<BleAdvertisementHeader::Version>(666);
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
BleAdvertisementHeader ble_advertisement_header{
bad_version, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader ble_advertisement_header(
bad_version, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue);
EXPECT_FALSE(ble_advertisement_header.IsValid());
}
@@ -68,12 +68,12 @@ TEST(BleAdvertisementHeaderTest, ConstructionFailsWithBadVersion) {
TEST(BleAdvertisementHeaderTest, ConstructionSucceedsWithZeroNumSlot) {
int num_slot = 0;
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, num_slot, service_id_bloom_filter,
advertisement_hash, kPsmValue};
BleAdvertisementHeader ble_advertisement_header(
kVersion, false, num_slot, service_id_bloom_filter, advertisement_hash,
kPsmValue);
EXPECT_TRUE(ble_advertisement_header.IsValid());
}
@@ -81,12 +81,12 @@ TEST(BleAdvertisementHeaderTest, ConstructionSucceedsWithZeroNumSlot) {
TEST(BleAdvertisementHeaderTest, ConstructionFailsWithNegativeNumSlot) {
int num_slot = -1;
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, num_slot, service_id_bloom_filter,
advertisement_hash, kPsmValue};
BleAdvertisementHeader ble_advertisement_header(
kVersion, false, num_slot, service_id_bloom_filter, advertisement_hash,
kPsmValue);
EXPECT_FALSE(ble_advertisement_header.IsValid());
}
@@ -95,13 +95,12 @@ TEST(BleAdvertisementHeaderTest,
ConstructionFailsWithShortServiceIdBloomFilter) {
char short_service_id_bloom_filter[] = "\x01\x02\x03\x04\x05\x06\x07\x08\x09";
ByteArray short_service_id_bloom_filter_bytes{short_service_id_bloom_filter};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
ByteArray short_service_id_bloom_filter_bytes(short_service_id_bloom_filter);
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader ble_advertisement_header{
kVersion, false,
kNumSlots, short_service_id_bloom_filter_bytes,
advertisement_hash, kPsmValue};
BleAdvertisementHeader ble_advertisement_header(
kVersion, false, kNumSlots, short_service_id_bloom_filter_bytes,
advertisement_hash, kPsmValue);
EXPECT_FALSE(ble_advertisement_header.IsValid());
}
@@ -112,11 +111,11 @@ TEST(BleAdvertisementHeaderTest,
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b";
ByteArray service_id_bloom_filter{long_service_id_bloom_filter};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
BleAdvertisementHeader ble_advertisement_header(
kVersion, false, kNumSlots, service_id_bloom_filter, advertisement_hash,
kPsmValue);
EXPECT_FALSE(ble_advertisement_header.IsValid());
}
@@ -124,12 +123,12 @@ TEST(BleAdvertisementHeaderTest,
TEST(BleAdvertisementHeaderTest, ConstructionFailsWithShortAdvertisementHash) {
char short_advertisement_hash[] = "\x0a\x0b\x0c";
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{short_advertisement_hash};
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash(short_advertisement_hash);
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
BleAdvertisementHeader ble_advertisement_header(
kVersion, false, kNumSlots, service_id_bloom_filter, advertisement_hash,
kPsmValue);
EXPECT_FALSE(ble_advertisement_header.IsValid());
}
@@ -137,8 +136,8 @@ TEST(BleAdvertisementHeaderTest, ConstructionFailsWithShortAdvertisementHash) {
TEST(BleAdvertisementHeaderTest, ConstructionFailsWithLongAdvertisementHash) {
char long_advertisement_hash[] = "\x0a\x0b\x0c\x0d\x0e";
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{long_advertisement_hash};
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash(long_advertisement_hash);
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
@@ -147,16 +146,16 @@ TEST(BleAdvertisementHeaderTest, ConstructionFailsWithLongAdvertisementHash) {
}
TEST(BleAdvertisementHeaderTest, ConstructionFromSerializedStringWorks) {
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader org_ble_advertisement_header{
kVersion, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
BleAdvertisementHeader org_ble_advertisement_header(
kVersion, false, kNumSlots, service_id_bloom_filter, advertisement_hash,
kPsmValue);
auto ble_advertisement_header_bytes = ByteArray(org_ble_advertisement_header);
BleAdvertisementHeader ble_advertisement_header{
ble_advertisement_header_bytes};
BleAdvertisementHeader ble_advertisement_header(
ble_advertisement_header_bytes);
EXPECT_TRUE(ble_advertisement_header.IsValid());
EXPECT_EQ(kVersion, ble_advertisement_header.GetVersion());
@@ -169,51 +168,20 @@ TEST(BleAdvertisementHeaderTest, ConstructionFromSerializedStringWorks) {
EXPECT_EQ(kPsmValue, ble_advertisement_header.GetPsm());
}
TEST(BleAdvertisementHeaderTest, ConstructionFromExtraBytesWorks) {
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
TEST(BleAdvertisementHeaderTest, ConstructionFromDecodedByteArrayFails) {
ByteArray service_id_bloom_filter((std::string(kServiceIDBloomFilter)));
ByteArray advertisement_hash((std::string(kAdvertisementHash)));
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
BleAdvertisementHeader ble_advertisement_header(
kVersion, false, kNumSlots, service_id_bloom_filter, advertisement_hash,
kPsmValue);
auto ble_advertisement_header_bytes = ByteArray(ble_advertisement_header);
ByteArray long_ble_advertisement_header_bytes{
ble_advertisement_header_bytes.size() + 1};
long_ble_advertisement_header_bytes.CopyAt(0, ble_advertisement_header_bytes);
// Decode the returned byte array and input as a parameter by construction.
BleAdvertisementHeader failed_ble_advertisement_header(
Base64Utils::Decode(ble_advertisement_header_bytes.AsStringView()));
BleAdvertisementHeader long_ble_advertisement_header{
long_ble_advertisement_header_bytes};
EXPECT_TRUE(long_ble_advertisement_header.IsValid());
EXPECT_EQ(kVersion, long_ble_advertisement_header.GetVersion());
EXPECT_FALSE(ble_advertisement_header.IsSupportExtendedAdvertisement());
EXPECT_EQ(kNumSlots, long_ble_advertisement_header.GetNumSlots());
EXPECT_EQ(service_id_bloom_filter,
long_ble_advertisement_header.GetServiceIdBloomFilter());
EXPECT_EQ(advertisement_hash,
long_ble_advertisement_header.GetAdvertisementHash());
EXPECT_EQ(kPsmValue, long_ble_advertisement_header.GetPsm());
}
TEST(BleAdvertisementHeaderTest, ConstructionFromShortLengthFails) {
ByteArray service_id_bloom_filter{std::string(kServiceIDBloomFilter)};
ByteArray advertisement_hash{std::string(kAdvertisementHash)};
BleAdvertisementHeader ble_advertisement_header{
kVersion, false, kNumSlots, service_id_bloom_filter,
advertisement_hash, kPsmValue};
auto ble_advertisement_header_bytes = ByteArray(ble_advertisement_header);
ByteArray short_ble_advertisement_header_bytes{
ble_advertisement_header_bytes.size() - 3};
short_ble_advertisement_header_bytes.CopyAt(0,
ble_advertisement_header_bytes);
BleAdvertisementHeader short_ble_advertisement_header{
short_ble_advertisement_header_bytes};
EXPECT_FALSE(short_ble_advertisement_header.IsValid());
EXPECT_FALSE(failed_ble_advertisement_header.IsValid());
}
TEST(BleAdvertisementHeaderTest, Hash) {