Scarfski/bitsery
1
0
Fork 0
mirror of https://github.com/fraillt/bitsery.git synced 2026-06-08 08:13:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

added adapter type for serializer/deserializer

Browse Source
This commit is contained in:
fraillt
2017-10-05 12:16:13 +03:00
parent 982374be42
commit 5ede853954
46 changed files with 1081 additions and 938 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
tests/buffer_endianness.cpp
View File

@@ -25,12 +25,12 @@
#include <bitsery/buffer_writer.h>
#include <bitsery/buffer_reader.h>
#include <bitsery/ext/value_range.h>
#include "serialization_test_utils.h"
using testing::Eq;
using testing::ContainerEq;
using bitsery::EndiannessType;
using bitsery::DefaultConfig;
using Buffer = bitsery::DefaultConfig::BufferType;
constexpr EndiannessType getInverseEndianness(EndiannessType e) {
return e == EndiannessType::LittleEndian
@@ -50,8 +50,10 @@ struct IntegralTypes {
int8_t e;
};
using InverseReader = bitsery::BasicReader<InverseEndiannessConfig, InputAdapter >;
TEST(BufferEndianness, WhenWriteBytesThenBytesAreSwapped) {
TEST(DataEndianness, WhenWriteBytesThenBytesAreSwapped) {
//fill initial values
IntegralTypes src{};
src.a = 0x1122334455667788;
@@ -70,7 +72,7 @@ TEST(BufferEndianness, WhenWriteBytesThenBytesAreSwapped) {
//create and write to buffer
Buffer buf{};
bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
Writer bw{buf};
bw.writeBytes<8>(src.a);
bw.writeBytes<4>(src.b);
bw.writeBytes<2>(src.c);
@@ -78,7 +80,7 @@ TEST(BufferEndianness, WhenWriteBytesThenBytesAreSwapped) {
bw.writeBytes<1>(src.e);
bw.flush();
//read from buffer using inverse endianness config
bitsery::BasicBufferReader<InverseEndiannessConfig> br{bw.getWrittenRange()};
InverseReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
IntegralTypes res{};
br.readBytes<8>(res.a);
br.readBytes<4>(res.b);
@@ -93,25 +95,25 @@ TEST(BufferEndianness, WhenWriteBytesThenBytesAreSwapped) {
EXPECT_THAT(res.e, Eq(resInv.e));
}
TEST(BufferEndianness, WhenWriteBuffer1ByteValuesThenEndiannessIsIgnored) {
TEST(DataEndianness, WhenWrite1ByteValuesThenEndiannessIsIgnored) {
//fill initial values
constexpr size_t SIZE = 4;
uint8_t src[SIZE] = {0xAA, 0xBB, 0xCC, 0xDD};
uint8_t res[SIZE] = {};
//create and write to buffer
Buffer buf{};
bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
Writer bw{buf};
bw.writeBuffer<1>(src, SIZE);
bw.flush();
//read from buffer using inverse endianness config
bitsery::BasicBufferReader<InverseEndiannessConfig> br{bw.getWrittenRange()};
InverseReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
br.readBuffer<1>(res, SIZE);
//result is identical, because we write separate values, of size 1byte, that requires no swapping
//check results
EXPECT_THAT(res, ContainerEq(src));
}
TEST(BufferEndianness, WhenWriteBufferMoreThan1ByteValuesThenValuesAreSwapped) {
TEST(DataEndianness, WhenWriteMoreThan1ByteValuesThenValuesAreSwapped) {
//fill initial values
constexpr size_t SIZE = 4;
uint16_t src[SIZE] = {0xAA00, 0xBB11, 0xCC22, 0xDD33};
@@ -119,11 +121,11 @@ TEST(BufferEndianness, WhenWriteBufferMoreThan1ByteValuesThenValuesAreSwapped) {
uint16_t res[SIZE] = {};
//create and write to buffer
Buffer buf{};
bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
Writer bw{buf};
bw.writeBuffer<2>(src, SIZE);
bw.flush();
//read from buffer using inverse endianness config
bitsery::BasicBufferReader<InverseEndiannessConfig> br{bw.getWrittenRange()};
InverseReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
br.readBuffer<2>(res, SIZE);
//result is identical, because we write separate values, of size 1byte, that requires no swapping
//check results
@@ -143,9 +145,7 @@ struct IntegralUnsignedTypes {
uint8_t d;
};
TEST(BufferEndianness, WhenBufferValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndianness) {
//fill initial values
static_assert(sizeof(bitsery::details::ContainerTraits<DefaultConfig::BufferType>::TValue) == 1, "currently only 1 byte size, value size is supported");
TEST(DataEndianness, WhenValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndianness) {
//fill initial values
constexpr IntegralUnsignedTypes src {
0x0000334455667788,//bits 19
@@ -160,16 +160,16 @@ TEST(BufferEndianness, WhenBufferValueTypeIs1ByteThenBitOperationsIsNotAffectedB
constexpr size_t dBITS = getBits(src.d) + 2;
//create and write to buffer
Buffer buf{};
bitsery::BasicBufferWriter<DefaultConfig> bw{buf};
bitsery::BitPackingWriter<DefaultConfig> bpw{bw};
Writer bw{buf};
bitsery::BitPackingWriter<Writer> bpw{bw};
bpw.writeBits(src.a, aBITS);
bpw.writeBits(src.b, bBITS);
bpw.writeBits(src.c, cBITS);
bpw.writeBits(src.d, dBITS);
bpw.flush();
//read from buffer using inverse endianness config
bitsery::BasicBufferReader<InverseEndiannessConfig> br{bpw.getWrittenRange()};
bitsery::BitPackingReader<InverseEndiannessConfig> bpr{br};
InverseReader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
bitsery::BitPackingReader<InverseReader> bpr{br};
IntegralUnsignedTypes res{};
bpr.readBits(res.a, aBITS);
bpr.readBits(res.b, bBITS);

117
tests/buffer_operations.cpp
View File

@@ -22,18 +22,15 @@
#include <gmock/gmock.h>
#include <bitsery/buffer_writer.h>
#include <bitsery/buffer_reader.h>
#include "serialization_test_utils.h"
#include <bitsery/ext/value_range.h>
using testing::Eq;
using testing::ContainerEq;
using bitsery::BufferWriter;
using bitsery::BufferReader;
using BitPackingWriter = bitsery::BitPackingWriter<bitsery::DefaultConfig>;
using BitPackingReader = bitsery::BitPackingReader<bitsery::DefaultConfig>;
using Buffer = bitsery::DefaultConfig::BufferType;
using BitPackingWriter = bitsery::BitPackingWriter<Writer>;
using BitPackingReader = bitsery::BitPackingReader<Reader>;
struct IntegralUnsignedTypes {
uint32_t a;
@@ -50,9 +47,9 @@ constexpr size_t getBits(T v) {
// *** bits operations
TEST(BufferBitsAndBytesOperations, WriteAndReadBitsMaxTypeValues) {
TEST(DataBitsAndBytesOperations, WriteAndReadBitsMaxTypeValues) {
Buffer buf;
BufferWriter bw{buf};
Writer bw{buf};
BitPackingWriter bpw{bw};
bpw.writeBits(std::numeric_limits<uint64_t>::max(), 64);
bpw.writeBits(std::numeric_limits<uint32_t>::max(), 32);
@@ -60,7 +57,7 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBitsMaxTypeValues) {
bpw.writeBits(std::numeric_limits<uint8_t>::max(), 8);
bpw.flush();
BufferReader br{bpw.getWrittenRange()};
Reader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
BitPackingReader bpr{br};
uint64_t v64{};
uint32_t v32{};
@@ -77,7 +74,7 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBitsMaxTypeValues) {
EXPECT_THAT(v8, Eq(std::numeric_limits<uint8_t>::max()));
}
TEST(BufferBitsAndBytesOperations, WriteAndReadBits) {
TEST(DataBitsAndBytesOperations, WriteAndReadBits) {
//setup data
constexpr IntegralUnsignedTypes data{
485454,//bits 19
@@ -95,7 +92,7 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBits) {
//create and write to buffer
Buffer buf;
BufferWriter bw{buf};
Writer bw{buf};
BitPackingWriter bpw{bw};
bpw.writeBits(data.a, aBITS);
@@ -104,11 +101,11 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBits) {
bpw.writeBits(data.d, dBITS);
bpw.writeBits(data.e, eBITS);
bpw.flush();
auto range = bpw.getWrittenRange();
auto writtenSize = bpw.getWrittenBytesCount();
auto bytesCount = ((aBITS + bBITS + cBITS + dBITS + eBITS) / 8) +1 ;
EXPECT_THAT(std::distance(range.begin(), range.end()), Eq(bytesCount));
EXPECT_THAT(writtenSize, Eq(bytesCount));
//read from buffer
BufferReader br{range};
Reader br{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr{br};
IntegralUnsignedTypes res{};
@@ -127,48 +124,48 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBits) {
}
TEST(BufferBitsAndBytesOperations, BufferSizeIsCountedPerByteNotPerBit) {
TEST(DataBitsAndBytesOperations, WrittenSizeIsCountedPerByteNotPerBit) {
//setup data
//create and write to buffer
Buffer buf;
BufferWriter bw{buf};
Writer bw{buf};
BitPackingWriter bpw{bw};
bpw.writeBits(7u,3);
bpw.flush();
auto range = bpw.getWrittenRange();
EXPECT_THAT(std::distance(range.begin(), range.end()), Eq(1));
auto writtenSize = bpw.getWrittenBytesCount();
EXPECT_THAT(writtenSize, Eq(1));
//read from buffer
BufferReader br{range};
Reader br{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr{br};
uint16_t tmp;
bpr.readBits(tmp,4);
bpr.readBits(tmp,2);
bpr.readBits(tmp,2);
EXPECT_THAT(bpr.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
bpr.readBits(tmp,2);
EXPECT_THAT(bpr.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));//false
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));//false
//part of next byte
BufferReader br1{range};
Reader br1{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr1{br1};
bpr1.readBits(tmp,2);
EXPECT_THAT(bpr1.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(bpr1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
bpr1.readBits(tmp,7);
EXPECT_THAT(bpr1.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));//false
EXPECT_THAT(bpr1.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));//false
//bigger than byte
BufferReader br2{range};
Reader br2{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr2{br2};
bpr2.readBits(tmp,9);
EXPECT_THAT(bpr2.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));//false
EXPECT_THAT(bpr2.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));//false
}
TEST(BufferBitsAndBytesOperations, ConsecutiveCallsToAlignHasNoEffect) {
TEST(DataBitsAndBytesOperations, ConsecutiveCallsToAlignHasNoEffect) {
Buffer buf;
BufferWriter bw{buf};
Writer bw{buf};
BitPackingWriter bpw{bw};
bpw.writeBits(3u, 2);
@@ -183,52 +180,52 @@ TEST(BufferBitsAndBytesOperations, ConsecutiveCallsToAlignHasNoEffect) {
bpw.flush();
unsigned char tmp;
BufferReader br{bpw.getWrittenRange()};
Reader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
BitPackingReader bpr{br};
bpr.readBits(tmp,2);
EXPECT_THAT(tmp, Eq(3u));
bpr.align();
EXPECT_THAT(bpr.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
bpr.readBits(tmp,3);
bpr.align();
bpr.align();
bpr.align();
EXPECT_THAT(tmp, Eq(7u));
EXPECT_THAT(bpr.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
bpr.readBits(tmp,4);
EXPECT_THAT(tmp, Eq(15u));
EXPECT_THAT(bpr.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
}
TEST(BufferBitsAndBytesOperations, AlignWritesZerosBits) {
TEST(DataBitsAndBytesOperations, AlignWritesZerosBits) {
//setup data
//create and write to buffer
Buffer buf;
BufferWriter bw{buf};
Writer bw{buf};
BitPackingWriter bpw{bw};
//write 2 bits and align
bpw.writeBits(3u, 2);
bpw.align();
bpw.flush();
auto range = bpw.getWrittenRange();
EXPECT_THAT(std::distance(range.begin(), range.end()), Eq(1));
auto writtenSize = bpw.getWrittenBytesCount();
EXPECT_THAT(writtenSize, Eq(1));
unsigned char tmp;
BufferReader br1{range};
Reader br1{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr1{br1};
bpr1.readBits(tmp,2);
//read aligned bits
bpr1.readBits(tmp,6);
EXPECT_THAT(tmp, Eq(0));
BufferReader br2{range};
Reader br2{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr2{br2};
//read 2 bits
bpr2.readBits(tmp,2);
bpr2.align();
EXPECT_THAT(bpr2.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(bpr2.getError(), Eq(bitsery::ReaderError::NO_ERROR));
}
@@ -243,7 +240,7 @@ struct IntegralTypes {
int8_t f[2];
};
TEST(BufferBitsAndBytesOperations, WriteAndReadBytes) {
TEST(DataBitsAndBytesOperations, WriteAndReadBytes) {
//setup data
IntegralTypes data;
data.a = -4894541654564;
@@ -256,7 +253,7 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBytes) {
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
bw.writeBytes<4>(data.b);
bw.writeBytes<2>(data.c);
bw.writeBytes<1>(data.d);
@@ -264,11 +261,11 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBytes) {
bw.writeBytes<1>(data.e);
bw.writeBuffer<1>(data.f, 2);
bw.flush();
auto range = bw.getWrittenRange();
auto writtenSize = bw.getWrittenBytesCount();
EXPECT_THAT(std::distance(range.begin(), range.end()), Eq(18));
EXPECT_THAT(writtenSize, Eq(18));
//read from buffer
BufferReader br{range};
Reader br{InputAdapter{buf.begin(), writtenSize}};
IntegralTypes res{};
br.readBytes<4>(res.b);
br.readBytes<2>(res.c);
@@ -276,7 +273,7 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBytes) {
br.readBytes<8>(res.a);
br.readBytes<1>(res.e);
br.readBuffer<1>(res.f, 2);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
//assert results
EXPECT_THAT(data.a, Eq(res.a));
@@ -288,69 +285,68 @@ TEST(BufferBitsAndBytesOperations, WriteAndReadBytes) {
}
TEST(BufferBitsAndBytesOperations, ReadWriteBufferFncCanAcceptSignedData) {
TEST(DataBitsAndBytesOperations, ReadWriteFncCanAcceptSignedData) {
//setup data
constexpr size_t DATA_SIZE = 3;
int16_t src[DATA_SIZE] {54,-4877,30067};
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
bw.writeBuffer<2>(src, DATA_SIZE);
bw.flush();
//read from buffer
BufferReader br1{bw.getWrittenRange()};
Reader br1{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
int16_t dst[DATA_SIZE]{};
br1.readBuffer<2>(dst, DATA_SIZE);
EXPECT_THAT(br1.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(dst, ContainerEq(src));
}
TEST(BufferBitsAndBytesOperations, ReadWriteBufferCanWorkOnUnalignedData) {
TEST(DataBitsAndBytesOperations, ReadWriteCanWorkOnUnalignedData) {
//setup data
constexpr size_t DATA_SIZE = 3;
int16_t src[DATA_SIZE] {54,-4877,30067};
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
BitPackingWriter bpw{bw};
bpw.writeBits(15u, 4);
bpw.writeBuffer<2>(src, DATA_SIZE);
bpw.writeBits(12u, 4);
bpw.flush();
auto range = bpw.getWrittenRange();
EXPECT_THAT(std::distance(range.begin(), range.end()), Eq(sizeof(src) + 1));
auto writtenSize = bpw.getWrittenBytesCount();
EXPECT_THAT(writtenSize, Eq(sizeof(src) + 1));
//read from buffer
BufferReader br1{range};
Reader br1{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr1{br1};
int16_t dst[DATA_SIZE]{};
uint8_t tmp{};
bpr1.readBits(tmp, 4);
EXPECT_THAT(tmp, Eq(15));
bpr1.readBuffer<2>(dst, DATA_SIZE);
EXPECT_THAT(bpr1.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(bpr1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(dst, ContainerEq(src));
bpr1.readBits(tmp, 4);
EXPECT_THAT(tmp, Eq(12));
}
TEST(BufferBitsAndBytesOperations, RegressionTestReadBytesAfterReadBitsWithLotsOfZeroBits) {
TEST(DataBitsAndBytesOperations, RegressionTestReadBytesAfterReadBitsWithLotsOfZeroBits) {
//setup data
int16_t data[2]{0x0000, 0x7FFF};
int16_t res[2]{};
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
BitPackingWriter bpw{bw};
bpw.writeBits(2u, 2);
bpw.writeBytes<2>(data[0]);
bpw.writeBytes<2>(data[1]);
bpw.align();
bpw.flush();
auto range = bpw.getWrittenRange();
//read from buffer
BufferReader br{range};
Reader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
BitPackingReader bpr{br};
uint8_t tmp{};
bpr.readBits(tmp, 2);
@@ -362,4 +358,3 @@ TEST(BufferBitsAndBytesOperations, RegressionTestReadBytesAfterReadBitsWithLotsO
EXPECT_THAT(res[1], Eq(data[1]));
}

58
tests/buffer_reading.cpp
View File

@@ -22,15 +22,11 @@
#include <gmock/gmock.h>
#include <bitsery/buffer_writer.h>
#include <bitsery/buffer_reader.h>
#include "serialization_test_utils.h"
#include <list>
#include <bitset>
using testing::Eq;
using bitsery::BufferWriter;
using bitsery::BufferReader;
using Buffer = bitsery::DefaultConfig::BufferType;
struct IntegralTypes {
int64_t a;
@@ -41,48 +37,48 @@ struct IntegralTypes {
int8_t f[2];
};
TEST(BufferReading, WhenReadingMoreThanAvailableThenEmptyBufferError) {
TEST(DataReading, WhenReadingMoreThanAvailableThenEmptyBufferError) {
//setup data
uint8_t a = 111;
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
bw.writeBytes<1>(a);
bw.writeBytes<1>(a);
bw.writeBytes<1>(a);
bw.flush();
//read from buffer
BufferReader br{bw.getWrittenRange()};
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
int32_t c;
br.readBytes<4>(c);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
}
TEST(BufferReading, WhenErrorOccursThenAllOtherOperationsFailsForSameError) {
TEST(DataReading, WhenErrorOccursThenAllOtherOperationsFailsForSameError) {
//setup data
uint8_t a = 111;
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
bw.writeBytes<1>(a);
bw.writeBytes<1>(a);
bw.writeBytes<1>(a);
bw.flush();
//read from buffer
BufferReader br{bw.getWrittenRange()};
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
int32_t c;
br.readBytes<4>(c);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
br.readBytes<1>(a);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
}
TEST(BufferReading, ReadIsCompletedSuccessfullyWhenAllBytesAreReadWithoutErrors) {
TEST(DataReading, ReadIsCompletedSuccessfullyWhenAllBytesAreReadWithoutErrors) {
//setup data
IntegralTypes data;
data.b = 94545646;
@@ -91,59 +87,59 @@ TEST(BufferReading, ReadIsCompletedSuccessfullyWhenAllBytesAreReadWithoutErrors)
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
bw.writeBytes<4>(data.b);
bw.writeBytes<2>(data.c);
bw.writeBytes<1>(data.d);
bw.flush();
//read from buffer
BufferReader br{bw.getWrittenRange()};
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
IntegralTypes res;
br.readBytes<4>(res.b);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
br.readBytes<2>(res.c);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br.isCompletedSuccessfully(), Eq(false));
br.readBytes<1>(res.d);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br.isCompletedSuccessfully(), Eq(true));
br.readBytes<1>(res.d);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br.isCompletedSuccessfully(), Eq(false));
BufferReader br1{bw.getWrittenRange()};
Reader br1{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
br1.readBytes<4>(res.b);
EXPECT_THAT(br1.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
br1.readBytes<2>(res.c);
EXPECT_THAT(br1.getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
br1.readBytes<2>(res.c);
EXPECT_THAT(br1.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
br1.readBytes<1>(res.d);
EXPECT_THAT(br1.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
}
TEST(BufferReading, WhenReaderHasErrorsAllOperationsReadsReturnZero) {
TEST(DataReading, WhenReaderHasErrorsAllOperationsReadsReturnZero) {
//setup data
uint8_t a = 111;
//create and write to buffer
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
bw.writeBytes<1>(a);
bw.writeBytes<1>(a);
bw.writeBytes<1>(a);
bw.flush();
//read from buffer
BufferReader br{bw.getWrittenRange()};
bitsery::BitPackingReader<bitsery::DefaultConfig> bpr{br};
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
bitsery::BitPackingReader<Reader> bpr{br};
int32_t c;
bpr.readBytes<4>(c);
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
int16_t r1= {-645};
uint32_t r2[2] = {54898,87854};

53
tests/buffer_reading_errors.cpp
View File

@@ -25,19 +25,18 @@
#include <bitsery/traits/string.h>
using testing::Eq;
using bitsery::BufferWriter;
using bitsery::BufferReader;
using Buffer = bitsery::DefaultConfig::BufferType;
using SessionsEnabledWriter = bitsery::BasicWriter<SessionsEnabledConfig, OutputAdapter>;
using SessionsEnabledReader = bitsery::BasicReader<SessionsEnabledConfig, InputAdapter>;
TEST(BufferReadingErrors, WhenContainerOrTextSizeIsMoreThanMaxThenInvalidBufferDataError) {
TEST(DataReadingErrors, WhenContainerOrTextSizeIsMoreThanMaxThenInvalidDataError) {
SerializationContext ctx;
std::string tmp = "larger text then allowed";
ctx.createSerializer().text1b(tmp,100);
ctx.createDeserializer().text1b(tmp, 10);
EXPECT_THAT(ctx.br->getError(), Eq(bitsery::BufferReaderError::INVALID_BUFFER_DATA));
EXPECT_THAT(ctx.br->getError(), Eq(bitsery::ReaderError::INVALID_DATA));
}
TEST(BufferReadingErrors, WhenReadingBoolByteReadsMoreThanOneThenInvalidBufferDataErrorAndResultIsFalse) {
TEST(DataReadingErrors, WhenReadingBoolByteReadsMoreThanOneThenInvalidBufferDataErrorAndResultIsFalse) {
SerializationContext ctx;
auto ser = ctx.createSerializer();
ser.value1b(uint8_t{1});
@@ -48,28 +47,28 @@ TEST(BufferReadingErrors, WhenReadingBoolByteReadsMoreThanOneThenInvalidBufferDa
EXPECT_THAT(res, Eq(true));
des.boolValue(res);
EXPECT_THAT(res, Eq(false));
EXPECT_THAT(ctx.br->getError(), Eq(bitsery::BufferReaderError::INVALID_BUFFER_DATA));
EXPECT_THAT(ctx.br->getError(), Eq(bitsery::ReaderError::INVALID_DATA));
}
TEST(BufferReadingErrors, WhenReadingAlignHasNonZerosThenInvalidBufferDataError) {
TEST(DataReadingErrors, WhenReadingAlignHasNonZerosThenInvalidDataError) {
Buffer buf{};
BufferWriter bw{buf};
Writer bw{buf};
uint8_t tmp{0xFF};
bw.writeBytes<1>(tmp);
bw.flush();
BufferReader br{bw.getWrittenRange()};
bitsery::BitPackingReader<bitsery::DefaultConfig> bpr{br};
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
bitsery::BitPackingReader<Reader> bpr{br};
bpr.readBits(tmp,3);
bpr.align();
EXPECT_THAT(bpr.getError(), Eq(bitsery::BufferReaderError::INVALID_BUFFER_DATA));
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
}
TEST(BufferReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidBufferError) {
TEST(DataReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidDataError) {
uint8_t tmp{0xFF};
Buffer buf{};
BufferWriter bw{buf};
SessionsEnabledWriter bw{buf};
for (auto i = 0; i < 2; ++i) {
bw.beginSession();
bw.writeBytes<1>(tmp);
@@ -77,7 +76,7 @@ TEST(BufferReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidBuffe
bw.endSession();
}
bw.flush();
BufferReader br{bw.getWrittenRange()};
SessionsEnabledReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
for (auto i = 0; i < 2; ++i) {
br.beginSession();
br.readBytes<1>(tmp);
@@ -86,37 +85,37 @@ TEST(BufferReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidBuffe
br.endSession();
br.endSession();
}
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::INVALID_BUFFER_DATA));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
}
TEST(BufferReadingErrors, WhenInitializingSessionsWhenNotEnoughDataThenInvalidBufferData) {
TEST(DataReadingErrors, WhenInitializingSessionsWhenNotEnoughDataThenInvalidData) {
uint8_t tmp1{0xFF};
Buffer buf1{};
BufferWriter bw1{buf1};
SessionsEnabledWriter bw1{buf1};
bw1.writeBytes<1>(tmp1);
bw1.flush();
BufferReader br1{bw1.getWrittenRange()};
SessionsEnabledReader br1{InputAdapter{buf1.begin(), bw1.getWrittenBytesCount()}};
br1.beginSession();
EXPECT_THAT(br1.getError(), Eq(bitsery::BufferReaderError::INVALID_BUFFER_DATA));
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
Buffer buf2{};
BufferWriter bw2{buf2};
SessionsEnabledWriter bw2{buf2};
uint16_t tmp2{0x8000};
bw2.writeBytes<2>(tmp2);
bw2.flush();
BufferReader br2{bw2.getWrittenRange()};
SessionsEnabledReader br2{InputAdapter{buf2.begin(), bw2.getWrittenBytesCount()}};
br2.beginSession();
EXPECT_THAT(br2.getError(), Eq(bitsery::BufferReaderError::INVALID_BUFFER_DATA));
EXPECT_THAT(br2.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
}
TEST(BufferReadingErrors, WhenInitializingSessionsWhereSessionsDataOffsetIsCorruptedThenInvalidBufferData) {
TEST(DataReadingErrors, WhenInitializingSessionsWhereSessionsDataOffsetIsCorruptedThenInvalidData) {
Buffer buf{};
BufferWriter bw{buf};
SessionsEnabledWriter bw{buf};
bw.writeBytes<1>(uint8_t{1});
bw.writeBytes<1>(uint8_t{1});
bw.writeBytes<2>(uint16_t{10});
BufferReader br{bw.getWrittenRange()};
SessionsEnabledReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
br.beginSession();
EXPECT_THAT(br.getError(), Eq(bitsery::BufferReaderError::INVALID_BUFFER_DATA));
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
}

94
tests/buffer_writing.cpp
View File

@@ -21,38 +21,27 @@
//SOFTWARE.
#include <gmock/gmock.h>
#include <bitsery/buffer_writer.h>
#include <bitsery/buffer_reader.h>
#include "serialization_test_utils.h"
#include <bitsery/details/serialization_common.h>
#include <bitsery/traits/array.h>
#include <bitsery/traits/vector.h>
using testing::Eq;
using testing::ContainerEq;
using bitsery::EndiannessType;
using bitsery::DefaultConfig;
using Buffer = bitsery::DefaultConfig::BufferType;
struct FixedBufferConfig: public DefaultConfig {
using BufferType = std::array<uint8_t, 100>;
};
struct NonFixedBufferConfig: public DefaultConfig {
using BufferType = std::vector<uint8_t>;
};
template <typename Config>
class BufferWriting:public testing::Test {
template <typename BufType>
class DataWriting:public testing::Test {
public:
using type = Config;
using TWriter = bitsery::BasicWriter<bitsery::DefaultConfig, bitsery::OutputBufferAdapter<BufType>>;
using TBuffer = BufType;
};
using BufferWritingConfigs = ::testing::Types<
NonFixedBufferConfig,
FixedBufferConfig>;
using NonFixedContainer = std::vector<uint8_t>;
using FixedContainer = std::array<uint8_t, 100>;
TYPED_TEST_CASE(BufferWriting, BufferWritingConfigs);
using ContainerTypes = ::testing::Types<FixedContainer,NonFixedContainer>;
TYPED_TEST_CASE(DataWriting, ContainerTypes);
static constexpr size_t DATA_SIZE = 14u;
@@ -67,50 +56,51 @@ void writeData(BW& bw) {
bw.template writeBytes<4>(tmp5);
}
TYPED_TEST(BufferWriting, GetWrittenRangeReturnsBeginEndIterators) {
using Config = typename TestFixture::type;
using Buffer = typename Config::BufferType;
Buffer buf{};
bitsery::BasicBufferWriter<Config> bw{buf};
TYPED_TEST(DataWriting, GetWrittenBytesCountReturnsActualBytesWritten) {
using TWriter = typename TestFixture::TWriter;
using TBuffer = typename TestFixture::TBuffer;
TBuffer buf{};
TWriter bw{buf};
writeData(bw);
bw.flush();
auto range = bw.getWrittenRange();
EXPECT_THAT(std::distance(range.begin(), range.end()), DATA_SIZE);
auto writtenSize = bw.getWrittenBytesCount();
EXPECT_THAT(writtenSize, DATA_SIZE);
EXPECT_THAT(buf.size(), ::testing::Ge(DATA_SIZE));
}
TYPED_TEST(BufferWriting, WhenWritingBitsThenMustFlushWriter) {
using Config = typename TestFixture::type;
using Buffer = typename Config::BufferType;
Buffer buf{};
bitsery::BasicBufferWriter<Config> bw{buf};
bitsery::BitPackingWriter<Config> bpw{bw};
TYPED_TEST(DataWriting, WhenWritingBitsThenMustFlushWriter) {
using TWriter = typename TestFixture::TWriter;
using TBuffer = typename TestFixture::TBuffer;
TBuffer buf{};
TWriter bw{buf};
bitsery::BitPackingWriter<TWriter> bpw{bw};
bpw.writeBits(3u, 2);
auto range1 = bpw.getWrittenRange();
auto writtenSize1 = bpw.getWrittenBytesCount();
bpw.flush();
auto range2 = bpw.getWrittenRange();
EXPECT_THAT(std::distance(range1.begin(), range1.end()), Eq(0));
EXPECT_THAT(std::distance(range2.begin(), range2.end()), Eq(1));
auto writtenSize2 = bpw.getWrittenBytesCount();
EXPECT_THAT(writtenSize1, Eq(0));
EXPECT_THAT(writtenSize2, Eq(1));
}
TYPED_TEST(BufferWriting, WhenDataAlignedThenFlushHasNoEffect) {
using Config = typename TestFixture::type;
using Buffer = typename Config::BufferType;
Buffer buf{};
bitsery::BasicBufferWriter<Config> bw{buf};
bitsery::BitPackingWriter<Config> bpw{bw};
TYPED_TEST(DataWriting, WhenDataAlignedThenFlushHasNoEffect) {
using TWriter = typename TestFixture::TWriter;
using TBuffer = typename TestFixture::TBuffer;
TBuffer buf{};
TWriter bw{buf};
bitsery::BitPackingWriter<TWriter> bpw{bw};
bpw.writeBits(3u, 2);
bpw.align();
auto range1 = bpw.getWrittenRange();
auto writtenSize1 = bpw.getWrittenBytesCount();
bpw.flush();
auto range2 = bpw.getWrittenRange();
EXPECT_THAT(std::distance(range1.begin(), range1.end()), Eq(1));
EXPECT_THAT(std::distance(range2.begin(), range2.end()), Eq(1));
auto writtenSize2 = bpw.getWrittenBytesCount();
EXPECT_THAT(writtenSize1, Eq(1));
EXPECT_THAT(writtenSize2, Eq(1));
}
TEST(BufferWrittingNonFixedBuffer, BufferIsAlwaysResizedToCapacity) {
using Buffer = typename NonFixedBufferConfig::BufferType;
Buffer buf{};
bitsery::BasicBufferWriter<NonFixedBufferConfig> bw{buf};
TEST(DataWritingNonFixedBufferContainer, ContainerIsAlwaysResizedToCapacity) {
NonFixedContainer buf{};
bitsery::BasicWriter<bitsery::DefaultConfig, bitsery::OutputBufferAdapter<NonFixedContainer>> bw{buf};
for (auto i = 0; i < 5; ++i) {
uint32_t tmp{};
bw.writeBytes<4>(tmp);

4
tests/serialization_bool.cpp
View File

@@ -27,10 +27,10 @@
using testing::Eq;
template <bool BitPackingEnabled>
using Serializer = bitsery::BasicSerializer<bitsery::DefaultConfig, BitPackingEnabled>;
using Serializer = bitsery::BasicSerializer<Writer, BitPackingEnabled>;
template <bool BitPackingEnabled>
using Deserializer = bitsery::BasicDeserializer<bitsery::DefaultConfig, BitPackingEnabled>;
using Deserializer = bitsery::BasicDeserializer<Reader, BitPackingEnabled>;
TEST(SerializeBooleans, BoolAsBit) {

2
tests/serialization_container.cpp
View File

@@ -80,7 +80,7 @@ public:
TContainer res{};
size_t getExpectedBufSize(const SerializationContext &ctx) const {
auto size = bitsery::details::ContainerTraits<TContainer>::size(src);
auto size = bitsery::traits::ContainerTraits<TContainer>::size(src);
return ctx.containerSizeSerializedBytesCount(size) + size * sizeof(TValue);
}
};

59
tests/serialization_ext_growable.cpp
View File

@@ -28,8 +28,6 @@ using namespace testing;
using bitsery::ext::Growable;
using Buffer = typename bitsery::DefaultConfig::BufferType;
struct DataV1 {
int32_t v1;
};
@@ -47,7 +45,7 @@ struct DataV3 {
TEST(SerializeExtensionGrowable, WriteSessionsDataAtBufferEndAfterFlush) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
ctx.createSerializer().ext(int8_t{}, Growable{}, [] (int8_t& v) { });
EXPECT_THAT(ctx.getBufferSize(), Eq(0));
ctx.bw->flush();
@@ -55,8 +53,8 @@ TEST(SerializeExtensionGrowable, WriteSessionsDataAtBufferEndAfterFlush) {
}
TEST(SerializeExtensionGrowable, SessionDataConsistOfSessionsEndPosAnd2BytesSessionsDataOffset) {
SerializationContext ctx;
TEST(SerializeExtensionGrowable, SessionDataConsistOfSessionsEndPosAnd4BytesSessionsDataOffset) {
BasicSerializationContext<SessionsEnabledConfig> ctx;
constexpr size_t DATA_SIZE = 4;
@@ -66,7 +64,7 @@ TEST(SerializeExtensionGrowable, SessionDataConsistOfSessionsEndPosAnd2BytesSess
ser.ext(data, Growable{}, [&ser](int32_t & v) { ser.value4b(v);});
ctx.createDeserializer();//to flush data and create buffer reader
EXPECT_THAT(ctx.getBufferSize(), Eq(3 + DATA_SIZE));
EXPECT_THAT(ctx.getBufferSize(), Eq(1+4 + DATA_SIZE));
//read value back
auto& br = *(ctx.br);
@@ -77,16 +75,16 @@ TEST(SerializeExtensionGrowable, SessionDataConsistOfSessionsEndPosAnd2BytesSess
bitsery::details::readSize(br, sessionEnd, 1000000u);
EXPECT_THAT(sessionEnd, Eq(DATA_SIZE));
//this is the the offset from the end of buffer where actual data ends
uint16_t sessionsOffset{};//bufferEnd - sessionsOffset = dataEnd
br.readBytes<2>(sessionsOffset);
EXPECT_THAT(sessionsOffset, Eq(1+2));//1byte for session info, 2 bytes for session offset variable
auto range = ctx.bw->getWrittenRange();
auto dSize = std::distance(range.begin(), std::next(range.end(), -sessionsOffset));
uint32_t sessionsOffset{};//bufferEnd - sessionsOffset = dataEnd
br.readBytes<4>(sessionsOffset);
EXPECT_THAT(sessionsOffset, Eq(1+4));//1byte for session info, 4 bytes for session offset variable
auto writtenSize = ctx.bw->getWrittenBytesCount();
auto dSize = writtenSize - sessionsOffset;
EXPECT_THAT(dSize, Eq(DATA_SIZE));
}
TEST(SerializeExtensionGrowable, WhenNestedSessionsThenStoreEachDepthAndSize) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV3 data{19457,846, 498418};
ctx.createSerializer();
ctx.bw->beginSession();
@@ -117,29 +115,8 @@ TEST(SerializeExtensionGrowable, WhenNestedSessionsThenStoreEachDepthAndSize) {
EXPECT_THAT(sessionEnd[2], Eq(12));
}
TEST(SerializeExtensionGrowable, WhenSessionsDataIsMoreThan0x7FFFThenWrite4BytesForSessionsOffset) {
SerializationContext ctx;
ctx.createSerializer();
//create more sessions that can fit in 2 bytes
for (auto i = 0u; i < 0x8000; ++i) {
ctx.bw->beginSession();
ctx.bw->endSession();
}
ctx.createDeserializer();//to flush data and create buffer reader
EXPECT_THAT(ctx.getBufferSize(), Eq(0x8000+4));
uint8_t tmp{};
for (auto i = 0u; i < 0x8000; ++i) {
ctx.br->beginSession();
ctx.br->endSession();
}
EXPECT_THAT(ctx.br->getError(), Eq(bitsery::BufferReaderError::NO_ERROR));
ctx.br->readBytes<1>(tmp);
EXPECT_THAT(ctx.br->getError(), Eq(bitsery::BufferReaderError::BUFFER_OVERFLOW));
}
TEST(SerializeExtensionGrowable, MultipleSessionsReadSameVersionData) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV2 data{8454,987451};
ctx.createSerializer();
auto& bw = (*ctx.bw);
@@ -165,7 +142,7 @@ TEST(SerializeExtensionGrowable, MultipleSessionsReadSameVersionData) {
}
TEST(SerializeExtensionGrowable, MultipleSessionsReadNewerVersionData) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV3 data{8454,987451,54};
ctx.createSerializer();
auto& bw = (*ctx.bw);
@@ -192,7 +169,7 @@ TEST(SerializeExtensionGrowable, MultipleSessionsReadNewerVersionData) {
}
TEST(SerializeExtensionGrowable, MultipleSessionsReadOlderVersionData) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV2 data{8454,987451};
ctx.createSerializer();
auto& bw = (*ctx.bw);
@@ -220,7 +197,7 @@ TEST(SerializeExtensionGrowable, MultipleSessionsReadOlderVersionData) {
}
TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadSameVersionData) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV2 data{8454,987451};
ctx.createSerializer();
auto& bw = (*ctx.bw);
@@ -256,7 +233,7 @@ TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadSameVersionData) {
}
TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadOlderVersionData) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV2 data{8454,987451};
ctx.createSerializer();
auto& bw = (*ctx.bw);
@@ -296,7 +273,7 @@ TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadOlderVersionData) {
}
TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadNewerVersionData1) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV3 data{8454,987451,54};
ctx.createSerializer();
auto& bw = (*ctx.bw);
@@ -352,7 +329,7 @@ TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadNewerVersionData1) {
}
TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadNewerVersionData2) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV3 data{8454,987451,54};
ctx.createSerializer();
auto& bw = (*ctx.bw);
@@ -414,7 +391,7 @@ TEST(SerializeExtensionGrowable, MultipleNestedSessionsReadNewerVersionData2) {
}
TEST(SerializeExtensionGrowable, SessionsStartsAtEndOfSerialization) {
SerializationContext ctx;
BasicSerializationContext<SessionsEnabledConfig> ctx;
DataV2 data{8454,987451};
ctx.createSerializer();
auto& bw = (*ctx.bw);

60
tests/serialization_test_utils.h
View File

@@ -24,9 +24,10 @@
#ifndef BITSERY_SERIALIZER_TEST_UTILS_H
#define BITSERY_SERIALIZER_TEST_UTILS_H
#include <bitsery/bitsery.h>
#include <memory>
#include <bitsery/bitsery.h>
#include <bitsery/traits/vector.h>
#include <bitsery/adapters/buffer_adapters.h>
/*
* define some types for testing
@@ -85,31 +86,41 @@ void serialize(S&s, MyStruct2& o) {
s.object(o.s1);
}
struct SessionsEnabledConfig: public bitsery::DefaultConfig {
static constexpr bool BufferSessionsEnabled = true;
};
class SerializationContext {
using Buffer = std::vector<uint8_t>;
using InputAdapter = bitsery::InputBufferAdapter<Buffer>;
using OutputAdapter = bitsery::OutputBufferAdapter<Buffer>;
using Writer = bitsery::BasicWriter<bitsery::DefaultConfig, OutputAdapter>;
using Reader = bitsery::BasicReader<bitsery::DefaultConfig, InputAdapter>;
template <typename Config = bitsery::DefaultConfig>
class BasicSerializationContext {
public:
bitsery::DefaultConfig::BufferType buf{};
std::unique_ptr<bitsery::BufferWriter> bw;
std::unique_ptr<bitsery::BufferReader> br;
std::unique_ptr<bitsery::BasicSerializer<bitsery::DefaultConfig, true>> sbp;
Buffer buf;
std::unique_ptr<bitsery::BasicWriter<Config, OutputAdapter>> bw;
std::unique_ptr<bitsery::BasicReader<Config, InputAdapter>> br;
std::unique_ptr<bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, true>> sbp;
bitsery::Serializer createSerializer() {
bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, false> createSerializer() {
//make_unique is not in c++11
bw = std::unique_ptr<bitsery::BufferWriter>(new bitsery::BufferWriter(buf));
return bitsery::Serializer{*bw};
bw = std::unique_ptr<bitsery::BasicWriter<Config, OutputAdapter>>(new bitsery::BasicWriter<Config, OutputAdapter>(buf));
return bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, false>{*bw};
};
bitsery::BasicSerializer<bitsery::DefaultConfig, true>& createBPEnabledSerializer() {
bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, true>& createBPEnabledSerializer() {
//make_unique is not in c++11
bw = std::unique_ptr<bitsery::BufferWriter>(new bitsery::BufferWriter(buf));
sbp = std::unique_ptr<bitsery::BasicSerializer<bitsery::DefaultConfig, true>>(
new bitsery::BasicSerializer<bitsery::DefaultConfig, true>{*bw});
bw = std::unique_ptr<bitsery::BasicWriter<Config, OutputAdapter>>(new bitsery::BasicWriter<Config, OutputAdapter>(buf));
sbp = std::unique_ptr<bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, true>>(
new bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, true>{*bw});
return *sbp;
};
size_t getBufferSize() const {
auto range = bw->getWrittenRange();
return std::distance(range.begin(), range.end());
return bw->getWrittenBytesCount();
}
//since all containers .size() method returns size_t, it cannot be directly serialized, because size_t is platform dependant
@@ -122,19 +133,24 @@ public:
return 4;
}
bitsery::Deserializer createDeserializer() {
bitsery::BasicDeserializer<bitsery::BasicReader<Config, InputAdapter>, false> createDeserializer() {
bw->flush();
//make_unique is not in c++11
br = std::unique_ptr<bitsery::BufferReader>(new bitsery::BufferReader(bw->getWrittenRange()));
return bitsery::Deserializer{*br};
br = std::unique_ptr<bitsery::BasicReader<Config, InputAdapter>>(
new bitsery::BasicReader<Config, InputAdapter>(InputAdapter{buf.begin(), bw->getWrittenBytesCount()}));
return bitsery::BasicDeserializer<bitsery::BasicReader<Config, InputAdapter>, false>{*br};
};
bitsery::BasicDeserializer<bitsery::DefaultConfig, true> createBPEnabledDeserializer() {
bitsery::BasicDeserializer<bitsery::BasicReader<Config, InputAdapter>, true> createBPEnabledDeserializer() {
sbp.reset(nullptr);
//make_unique is not in c++11
br = std::unique_ptr<bitsery::BufferReader>(new bitsery::BufferReader(bw->getWrittenRange()));
return bitsery::BasicDeserializer<bitsery::DefaultConfig, true>{*br};
br = std::unique_ptr<bitsery::BasicReader<Config, InputAdapter>>(
new bitsery::BasicReader<Config, InputAdapter>(InputAdapter{buf.begin(), bw->getWrittenBytesCount()}));
return bitsery::BasicDeserializer<bitsery::BasicReader<Config, InputAdapter>, true>{*br};
};
};
//helper type
using SerializationContext = BasicSerializationContext<bitsery::DefaultConfig>;
#endif //BITSERY_SERIALIZER_TEST_UTILS_H