/*
* 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 "packet/packet_builder.h"
#include <gtest/gtest.h>
#include <forward_list>
#include <memory>
using bluetooth::packet::BasePacketBuilder;
using bluetooth::packet::BitInserter;
using bluetooth::packet::PacketBuilder;
using std::vector;
namespace {
vector<uint8_t> count_all = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
};
vector<uint8_t> count_1 = {
0x00,
0x01,
0x02,
};
vector<uint8_t> count_2 = {
0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
};
vector<uint8_t> count_3 = {
0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
};
} // namespace
namespace bluetooth {
namespace packet {
template <bool little_endian>
class EndianBuilder : public PacketBuilder<little_endian> {
public:
EndianBuilder(uint8_t byte, uint16_t two_bytes, uint32_t four_bytes, uint64_t eight_bytes)
: byte_(byte), two_bytes_(two_bytes), four_bytes_(four_bytes), eight_bytes_(eight_bytes) {}
~EndianBuilder() = default;
virtual size_t size() const override {
return sizeof(signature_) + sizeof(byte_) + sizeof(two_bytes_) + sizeof(four_bytes_) + sizeof(eight_bytes_);
}
virtual const std::unique_ptr<std::vector<uint8_t>> FinalPacket() {
std::unique_ptr<std::vector<uint8_t>> packet = std::make_unique<std::vector<uint8_t>>();
packet->reserve(size());
BitInserter it(*packet);
Serialize(it);
return packet;
}
virtual void Serialize(BitInserter& it) const override {
PacketBuilder<little_endian>::insert(signature_, it);
PacketBuilder<little_endian>::insert(byte_, it);
PacketBuilder<little_endian>::insert(two_bytes_, it);
PacketBuilder<little_endian>::insert(four_bytes_, it);
PacketBuilder<little_endian>::insert(eight_bytes_, it);
}
private:
uint32_t signature_{(little_endian ? 0x03020100 : 0x00010203)};
uint8_t byte_;
uint16_t two_bytes_;
uint32_t four_bytes_;
uint64_t eight_bytes_;
};
class PacketBuilderEndianTest : public ::testing::Test {
public:
PacketBuilderEndianTest() = default;
~PacketBuilderEndianTest() = default;
};
TEST(PacketBuilderEndianTest, insertTest) {
EndianBuilder<true> little(0x04, 0x0605, 0x0a090807, 0x1211100f0e0d0c0b);
EndianBuilder<false> big(0x04, 0x0506, 0x0708090a, 0x0b0c0d0e0f101112);
ASSERT_EQ(*big.FinalPacket(), *little.FinalPacket());
}
template <typename T>
class VectorBuilder : public PacketBuilder<true> {
public:
VectorBuilder(std::vector<uint64_t> vect) {
for (uint64_t element : vect) {
vect.push_back(static_cast<T>(element));
}
}
~VectorBuilder() = default;
virtual size_t size() const override {
return vect_.size() * sizeof(T);
}
virtual const std::unique_ptr<std::vector<uint8_t>> FinalPacket() {
std::unique_ptr<std::vector<uint8_t>> packet = std::make_unique<std::vector<uint8_t>>();
packet->reserve(size());
BitInserter it(*packet);
Serialize(it);
return packet;
}
virtual void Serialize(BitInserter& it) const override {
PacketBuilder<true>::insert_vector(vect_, it);
}
private:
std::vector<T> vect_;
};
template <typename T>
class InsertElementsBuilder : public PacketBuilder<true> {
public:
InsertElementsBuilder(std::vector<uint64_t> vect) {
for (uint64_t element : vect) {
vect.push_back(static_cast<T>(element));
}
}
virtual ~InsertElementsBuilder() = default;
virtual size_t size() const override {
return vect_.size() * sizeof(T);
}
virtual const std::unique_ptr<std::vector<uint8_t>> FinalPacket() {
std::unique_ptr<std::vector<uint8_t>> packet = std::make_unique<std::vector<uint8_t>>();
packet->reserve(size());
BitInserter it(*packet);
Serialize(it);
return packet;
}
virtual void Serialize(BitInserter& it) const override {
for (T elem : vect_) {
PacketBuilder<true>::insert(elem, it);
}
}
private:
std::vector<T> vect_;
};
std::vector<uint64_t> vector_data{
0x7060504030201000, 0x7161514131211101, 0x7262524232221202, 0x7363534333231303, 0x7464544434241404,
0x7565554535251505, 0x7666564636261606, 0x7767574737271707, 0x7868584838281808,
};
template <typename T>
class VectorBuilderTest : public ::testing::Test {
public:
VectorBuilderTest() = default;
~VectorBuilderTest() = default;
void SetUp() {
packet_1_ = std::shared_ptr<VectorBuilder<T>>(new VectorBuilder<T>(vector_data));
packet_2_ = std::shared_ptr<InsertElementsBuilder<T>>(new InsertElementsBuilder<T>(vector_data));
}
void TearDown() {
packet_1_.reset();
packet_2_.reset();
}
std::shared_ptr<VectorBuilder<T>> packet_1_;
std::shared_ptr<InsertElementsBuilder<T>> packet_2_;
};
using VectorBaseTypes = ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t>;
TYPED_TEST_CASE(VectorBuilderTest, VectorBaseTypes);
TYPED_TEST(VectorBuilderTest, insertVectorTest) {
ASSERT_EQ(*(this->packet_1_->FinalPacket()), *(this->packet_2_->FinalPacket()));
}
class NestedBuilder : public PacketBuilder<true> {
public:
~NestedBuilder() = default;
virtual size_t size() const override {
size_t payload_size = (payload_ ? payload_->size() : 0);
return 1 + payload_size;
}
static std::unique_ptr<NestedBuilder> Create(uint8_t level) {
return std::unique_ptr<NestedBuilder>(new NestedBuilder(level));
}
static std::unique_ptr<NestedBuilder> CreateNested(std::unique_ptr<BasePacketBuilder> payload, uint8_t level) {
return std::unique_ptr<NestedBuilder>(new NestedBuilder(std::move(payload), level));
}
virtual const std::unique_ptr<std::vector<uint8_t>> FinalPacket() {
std::unique_ptr<std::vector<uint8_t>> packet = std::make_unique<std::vector<uint8_t>>();
packet->reserve(size());
BitInserter it(*packet);
Serialize(it);
return packet;
}
virtual void Serialize(BitInserter& it) const override {
PacketBuilder<true>::insert(level_, it);
if (payload_) {
payload_->Serialize(it);
}
}
private:
std::unique_ptr<BasePacketBuilder> payload_;
uint8_t level_;
NestedBuilder(std::unique_ptr<BasePacketBuilder> inner, uint8_t level) : payload_(std::move(inner)), level_(level) {}
NestedBuilder(uint8_t level) : level_(level) {}
};
class BuilderBuilderTest : public ::testing::Test {};
TEST(BuilderBuilderTest, nestingTest) {
std::unique_ptr<BasePacketBuilder> innermost = NestedBuilder::Create(0);
std::unique_ptr<BasePacketBuilder> number_1 = NestedBuilder::CreateNested(std::move(innermost), 1);
std::unique_ptr<BasePacketBuilder> number_2 = NestedBuilder::CreateNested(std::move(number_1), 2);
std::unique_ptr<BasePacketBuilder> number_3 = NestedBuilder::CreateNested(std::move(number_2), 3);
std::unique_ptr<BasePacketBuilder> number_4 = NestedBuilder::CreateNested(std::move(number_3), 4);
std::unique_ptr<NestedBuilder> number_5 = NestedBuilder::CreateNested(std::move(number_4), 5);
std::vector<uint8_t> count_down{5, 4, 3, 2, 1, 0};
ASSERT_EQ(*number_5->FinalPacket(), count_down);
}
} // namespace packet
} // namespace bluetooth