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

new stream adapter, and lots of refactorings

Browse Source
This commit is contained in:
fraillt
2017-10-06 13:50:04 +03:00
parent 5ede853954
commit f3c9a33849
46 changed files with 967 additions and 701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/CMakeLists.txt
View File

@@ -52,7 +52,7 @@ include(${ExtCMakeFilesDir}/LinkTestLib.cmake)
FOREACH(TestFile ${TestSourceFiles})
get_filename_component(TestName ${TestFile} NAME_WE)
set(TestName TEST_${TestName})
add_executable(${TestName} ${TestFile} ${IncludeHeaders})
add_executable(${TestName} ${TestFile} ${IncludeHeaders} serialization_test_utils.h)
LinkTestLib(${TestName})
add_test(NAME ${TestName} COMMAND $<TARGET_FILE:${TestName}>)

26
tests/buffer_endianness.cpp → tests/data_endianness.cpp
View File

@@ -22,8 +22,8 @@
#include <gmock/gmock.h>
#include <bitsery/buffer_writer.h>
#include <bitsery/buffer_reader.h>
#include <bitsery/adapter_writer.h>
#include <bitsery/adapter_reader.h>
#include <bitsery/ext/value_range.h>
#include "serialization_test_utils.h"
@@ -50,7 +50,7 @@ struct IntegralTypes {
int8_t e;
};
using InverseReader = bitsery::BasicReader<InverseEndiannessConfig, InputAdapter >;
using InverseReader = bitsery::AdapterReader<InputAdapter, InverseEndiannessConfig>;
TEST(DataEndianness, WhenWriteBytesThenBytesAreSwapped) {
@@ -80,7 +80,7 @@ TEST(DataEndianness, WhenWriteBytesThenBytesAreSwapped) {
bw.writeBytes<1>(src.e);
bw.flush();
//read from buffer using inverse endianness config
InverseReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
IntegralTypes res{};
br.readBytes<8>(res.a);
br.readBytes<4>(res.b);
@@ -106,7 +106,7 @@ TEST(DataEndianness, WhenWrite1ByteValuesThenEndiannessIsIgnored) {
bw.writeBuffer<1>(src, SIZE);
bw.flush();
//read from buffer using inverse endianness config
InverseReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
br.readBuffer<1>(res, SIZE);
//result is identical, because we write separate values, of size 1byte, that requires no swapping
//check results
@@ -125,7 +125,7 @@ TEST(DataEndianness, WhenWriteMoreThan1ByteValuesThenValuesAreSwapped) {
bw.writeBuffer<2>(src, SIZE);
bw.flush();
//read from buffer using inverse endianness config
InverseReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
InverseReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
br.readBuffer<2>(res, SIZE);
//result is identical, because we write separate values, of size 1byte, that requires no swapping
//check results
@@ -148,10 +148,10 @@ struct IntegralUnsignedTypes {
TEST(DataEndianness, WhenValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndianness) {
//fill initial values
constexpr IntegralUnsignedTypes src {
0x0000334455667788,//bits 19
0x00CCDDEE,//bits 16
0x00DD,//bits 1
0x0F,//bits 6
0x0000334455667788,
0x00CCDDEE,
0x00DD,
0x0F,
};
constexpr size_t aBITS = getBits(src.a) + 8;
@@ -161,15 +161,15 @@ TEST(DataEndianness, WhenValueTypeIs1ByteThenBitOperationsIsNotAffectedByEndiann
//create and write to buffer
Buffer buf{};
Writer bw{buf};
bitsery::BitPackingWriter<Writer> bpw{bw};
bitsery::AdapterWriterBitPackingWrapper<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
InverseReader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
bitsery::BitPackingReader<InverseReader> bpr{br};
InverseReader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
bitsery::AdapterReaderBitPackingWrapper<InverseReader> bpr{br};
IntegralUnsignedTypes res{};
bpr.readBits(res.a, aBITS);
bpr.readBits(res.b, bBITS);

80
tests/buffer_operations.cpp → tests/data_operations.cpp
View File

@@ -28,8 +28,8 @@
using testing::Eq;
using testing::ContainerEq;
using BitPackingWriter = bitsery::BitPackingWriter<Writer>;
using BitPackingReader = bitsery::BitPackingReader<Reader>;
using AdapterBitPackingWriter = bitsery::AdapterWriterBitPackingWrapper<Writer>;
using AdapterBitPackingReader = bitsery::AdapterReaderBitPackingWrapper<Reader>;
struct IntegralUnsignedTypes {
@@ -50,15 +50,15 @@ constexpr size_t getBits(T v) {
TEST(DataBitsAndBytesOperations, WriteAndReadBitsMaxTypeValues) {
Buffer buf;
Writer bw{buf};
BitPackingWriter bpw{bw};
AdapterBitPackingWriter bpw{bw};
bpw.writeBits(std::numeric_limits<uint64_t>::max(), 64);
bpw.writeBits(std::numeric_limits<uint32_t>::max(), 32);
bpw.writeBits(std::numeric_limits<uint16_t>::max(), 16);
bpw.writeBits(std::numeric_limits<uint8_t>::max(), 8);
bpw.flush();
Reader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
BitPackingReader bpr{br};
Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
AdapterBitPackingReader bpr{br};
uint64_t v64{};
uint32_t v32{};
uint16_t v16{};
@@ -93,7 +93,7 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBits) {
//create and write to buffer
Buffer buf;
Writer bw{buf};
BitPackingWriter bpw{bw};
AdapterBitPackingWriter bpw{bw};
bpw.writeBits(data.a, aBITS);
bpw.writeBits(data.b, bBITS);
@@ -101,12 +101,12 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBits) {
bpw.writeBits(data.d, dBITS);
bpw.writeBits(data.e, eBITS);
bpw.flush();
auto writtenSize = bpw.getWrittenBytesCount();
auto writtenSize = bpw.writtenBytesCount();
auto bytesCount = ((aBITS + bBITS + cBITS + dBITS + eBITS) / 8) +1 ;
EXPECT_THAT(writtenSize, Eq(bytesCount));
//read from buffer
Reader br{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr{br};
AdapterBitPackingReader bpr{br};
IntegralUnsignedTypes res{};
@@ -130,43 +130,43 @@ TEST(DataBitsAndBytesOperations, WrittenSizeIsCountedPerByteNotPerBit) {
//create and write to buffer
Buffer buf;
Writer bw{buf};
BitPackingWriter bpw{bw};
AdapterBitPackingWriter bpw{bw};
bpw.writeBits(7u,3);
bpw.flush();
auto writtenSize = bpw.getWrittenBytesCount();
auto writtenSize = bpw.writtenBytesCount();
EXPECT_THAT(writtenSize, Eq(1));
//read from buffer
Reader br{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr{br};
AdapterBitPackingReader bpr{br};
uint16_t tmp;
bpr.readBits(tmp,4);
bpr.readBits(tmp,2);
bpr.readBits(tmp,2);
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
bpr.readBits(tmp,2);
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));//false
EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::DataOverflow));//false
//part of next byte
Reader br1{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr1{br1};
AdapterBitPackingReader bpr1{br1};
bpr1.readBits(tmp,2);
EXPECT_THAT(bpr1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::NoError));
bpr1.readBits(tmp,7);
EXPECT_THAT(bpr1.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));//false
EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::DataOverflow));//false
//bigger than byte
Reader br2{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr2{br2};
AdapterBitPackingReader bpr2{br2};
bpr2.readBits(tmp,9);
EXPECT_THAT(bpr2.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));//false
EXPECT_THAT(bpr2.error(), Eq(bitsery::ReaderError::DataOverflow));//false
}
TEST(DataBitsAndBytesOperations, ConsecutiveCallsToAlignHasNoEffect) {
Buffer buf;
Writer bw{buf};
BitPackingWriter bpw{bw};
AdapterBitPackingWriter bpw{bw};
bpw.writeBits(3u, 2);
//3 calls to align after 1st data
@@ -180,22 +180,22 @@ TEST(DataBitsAndBytesOperations, ConsecutiveCallsToAlignHasNoEffect) {
bpw.flush();
unsigned char tmp;
Reader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
BitPackingReader bpr{br};
Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
AdapterBitPackingReader bpr{br};
bpr.readBits(tmp,2);
EXPECT_THAT(tmp, Eq(3u));
bpr.align();
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
bpr.readBits(tmp,3);
bpr.align();
bpr.align();
bpr.align();
EXPECT_THAT(tmp, Eq(7u));
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
bpr.readBits(tmp,4);
EXPECT_THAT(tmp, Eq(15u));
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::NoError));
}
TEST(DataBitsAndBytesOperations, AlignWritesZerosBits) {
@@ -204,28 +204,28 @@ TEST(DataBitsAndBytesOperations, AlignWritesZerosBits) {
//create and write to buffer
Buffer buf;
Writer bw{buf};
BitPackingWriter bpw{bw};
AdapterBitPackingWriter bpw{bw};
//write 2 bits and align
bpw.writeBits(3u, 2);
bpw.align();
bpw.flush();
auto writtenSize = bpw.getWrittenBytesCount();
auto writtenSize = bpw.writtenBytesCount();
EXPECT_THAT(writtenSize, Eq(1));
unsigned char tmp;
Reader br1{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr1{br1};
AdapterBitPackingReader bpr1{br1};
bpr1.readBits(tmp,2);
//read aligned bits
bpr1.readBits(tmp,6);
EXPECT_THAT(tmp, Eq(0));
Reader br2{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr2{br2};
AdapterBitPackingReader bpr2{br2};
//read 2 bits
bpr2.readBits(tmp,2);
bpr2.align();
EXPECT_THAT(bpr2.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(bpr2.error(), Eq(bitsery::ReaderError::NoError));
}
@@ -261,7 +261,7 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBytes) {
bw.writeBytes<1>(data.e);
bw.writeBuffer<1>(data.f, 2);
bw.flush();
auto writtenSize = bw.getWrittenBytesCount();
auto writtenSize = bw.writtenBytesCount();
EXPECT_THAT(writtenSize, Eq(18));
//read from buffer
@@ -273,7 +273,7 @@ TEST(DataBitsAndBytesOperations, WriteAndReadBytes) {
br.readBytes<8>(res.a);
br.readBytes<1>(res.e);
br.readBuffer<1>(res.f, 2);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
//assert results
EXPECT_THAT(data.a, Eq(res.a));
@@ -295,10 +295,10 @@ TEST(DataBitsAndBytesOperations, ReadWriteFncCanAcceptSignedData) {
bw.writeBuffer<2>(src, DATA_SIZE);
bw.flush();
//read from buffer
Reader br1{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
Reader br1{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
int16_t dst[DATA_SIZE]{};
br1.readBuffer<2>(dst, DATA_SIZE);
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::NoError));
EXPECT_THAT(dst, ContainerEq(src));
}
@@ -309,23 +309,23 @@ TEST(DataBitsAndBytesOperations, ReadWriteCanWorkOnUnalignedData) {
//create and write to buffer
Buffer buf{};
Writer bw{buf};
BitPackingWriter bpw{bw};
AdapterBitPackingWriter bpw{bw};
bpw.writeBits(15u, 4);
bpw.writeBuffer<2>(src, DATA_SIZE);
bpw.writeBits(12u, 4);
bpw.flush();
auto writtenSize = bpw.getWrittenBytesCount();
auto writtenSize = bpw.writtenBytesCount();
EXPECT_THAT(writtenSize, Eq(sizeof(src) + 1));
//read from buffer
Reader br1{InputAdapter{buf.begin(), writtenSize}};
BitPackingReader bpr1{br1};
AdapterBitPackingReader 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::ReaderError::NO_ERROR));
EXPECT_THAT(bpr1.error(), Eq(bitsery::ReaderError::NoError));
EXPECT_THAT(dst, ContainerEq(src));
bpr1.readBits(tmp, 4);
EXPECT_THAT(tmp, Eq(12));
@@ -338,7 +338,7 @@ TEST(DataBitsAndBytesOperations, RegressionTestReadBytesAfterReadBitsWithLotsOfZ
//create and write to buffer
Buffer buf{};
Writer bw{buf};
BitPackingWriter bpw{bw};
AdapterBitPackingWriter bpw{bw};
bpw.writeBits(2u, 2);
bpw.writeBytes<2>(data[0]);
bpw.writeBytes<2>(data[1]);
@@ -346,8 +346,8 @@ TEST(DataBitsAndBytesOperations, RegressionTestReadBytesAfterReadBitsWithLotsOfZ
bpw.flush();
//read from buffer
Reader br{InputAdapter{buf.begin(), bpw.getWrittenBytesCount()}};
BitPackingReader bpr{br};
Reader br{InputAdapter{buf.begin(), bpw.writtenBytesCount()}};
AdapterBitPackingReader bpr{br};
uint8_t tmp{};
bpr.readBits(tmp, 2);
EXPECT_THAT(tmp, Eq(2));

36
tests/buffer_reading.cpp → tests/data_reading.cpp
View File

@@ -50,10 +50,10 @@ TEST(DataReading, WhenReadingMoreThanAvailableThenEmptyBufferError) {
bw.writeBytes<1>(a);
bw.flush();
//read from buffer
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
int32_t c;
br.readBytes<4>(c);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
}
TEST(DataReading, WhenErrorOccursThenAllOtherOperationsFailsForSameError) {
@@ -69,12 +69,12 @@ TEST(DataReading, WhenErrorOccursThenAllOtherOperationsFailsForSameError) {
bw.writeBytes<1>(a);
bw.flush();
//read from buffer
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
int32_t c;
br.readBytes<4>(c);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
br.readBytes<1>(a);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
}
@@ -94,31 +94,31 @@ TEST(DataReading, ReadIsCompletedSuccessfullyWhenAllBytesAreReadWithoutErrors) {
bw.writeBytes<1>(data.d);
bw.flush();
//read from buffer
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
IntegralTypes res;
br.readBytes<4>(res.b);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
br.readBytes<2>(res.c);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
EXPECT_THAT(br.isCompletedSuccessfully(), Eq(false));
br.readBytes<1>(res.d);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::NoError));
EXPECT_THAT(br.isCompletedSuccessfully(), Eq(true));
br.readBytes<1>(res.d);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
EXPECT_THAT(br.isCompletedSuccessfully(), Eq(false));
Reader br1{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
Reader br1{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
br1.readBytes<4>(res.b);
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::NoError));
br1.readBytes<2>(res.c);
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::NO_ERROR));
EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::NoError));
EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
br1.readBytes<2>(res.c);
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::DataOverflow));
EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
br1.readBytes<1>(res.d);
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::DataOverflow));
EXPECT_THAT(br1.isCompletedSuccessfully(), Eq(false));
}
@@ -135,11 +135,11 @@ TEST(DataReading, WhenReaderHasErrorsAllOperationsReadsReturnZero) {
bw.writeBytes<1>(a);
bw.flush();
//read from buffer
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
bitsery::BitPackingReader<Reader> bpr{br};
Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
bitsery::AdapterReaderBitPackingWrapper<Reader> bpr{br};
int32_t c;
bpr.readBytes<4>(c);
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::DATA_OVERFLOW));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::DataOverflow));
int16_t r1= {-645};
uint32_t r2[2] = {54898,87854};

34
tests/buffer_reading_errors.cpp → tests/data_reading_errors.cpp
View File

@@ -25,29 +25,29 @@
#include <bitsery/traits/string.h>
using testing::Eq;
using SessionsEnabledWriter = bitsery::BasicWriter<SessionsEnabledConfig, OutputAdapter>;
using SessionsEnabledReader = bitsery::BasicReader<SessionsEnabledConfig, InputAdapter>;
using SessionsEnabledWriter = bitsery::AdapterWriter<OutputAdapter, SessionsEnabledConfig>;
using SessionsEnabledReader = bitsery::AdapterReader<InputAdapter, SessionsEnabledConfig>;
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::ReaderError::INVALID_DATA));
EXPECT_THAT(ctx.br->error(), Eq(bitsery::ReaderError::InvalidData));
}
TEST(DataReadingErrors, WhenReadingBoolByteReadsMoreThanOneThenInvalidBufferDataErrorAndResultIsFalse) {
SerializationContext ctx;
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.value1b(uint8_t{1});
ser.value1b(uint8_t{2});
bool res{};
auto des = ctx.createDeserializer();
auto& des = ctx.createDeserializer();
des.boolValue(res);
EXPECT_THAT(res, Eq(true));
des.boolValue(res);
EXPECT_THAT(res, Eq(false));
EXPECT_THAT(ctx.br->getError(), Eq(bitsery::ReaderError::INVALID_DATA));
EXPECT_THAT(ctx.br->error(), Eq(bitsery::ReaderError::InvalidData));
}
TEST(DataReadingErrors, WhenReadingAlignHasNonZerosThenInvalidDataError) {
@@ -57,12 +57,12 @@ TEST(DataReadingErrors, WhenReadingAlignHasNonZerosThenInvalidDataError) {
bw.writeBytes<1>(tmp);
bw.flush();
Reader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
bitsery::BitPackingReader<Reader> bpr{br};
Reader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
bitsery::AdapterReaderBitPackingWrapper<Reader> bpr{br};
bpr.readBits(tmp,3);
bpr.align();
EXPECT_THAT(bpr.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
EXPECT_THAT(bpr.error(), Eq(bitsery::ReaderError::InvalidData));
}
TEST(DataReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidDataError) {
@@ -76,7 +76,7 @@ TEST(DataReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidDataErr
bw.endSession();
}
bw.flush();
SessionsEnabledReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
SessionsEnabledReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
for (auto i = 0; i < 2; ++i) {
br.beginSession();
br.readBytes<1>(tmp);
@@ -85,7 +85,7 @@ TEST(DataReadingErrors, WhenReadingNewSessionInMiddleOfOldDataThenInvalidDataErr
br.endSession();
br.endSession();
}
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::InvalidData));
}
@@ -95,18 +95,18 @@ TEST(DataReadingErrors, WhenInitializingSessionsWhenNotEnoughDataThenInvalidData
SessionsEnabledWriter bw1{buf1};
bw1.writeBytes<1>(tmp1);
bw1.flush();
SessionsEnabledReader br1{InputAdapter{buf1.begin(), bw1.getWrittenBytesCount()}};
SessionsEnabledReader br1{InputAdapter{buf1.begin(), bw1.writtenBytesCount()}};
br1.beginSession();
EXPECT_THAT(br1.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
EXPECT_THAT(br1.error(), Eq(bitsery::ReaderError::InvalidData));
Buffer buf2{};
SessionsEnabledWriter bw2{buf2};
uint16_t tmp2{0x8000};
bw2.writeBytes<2>(tmp2);
bw2.flush();
SessionsEnabledReader br2{InputAdapter{buf2.begin(), bw2.getWrittenBytesCount()}};
SessionsEnabledReader br2{InputAdapter{buf2.begin(), bw2.writtenBytesCount()}};
br2.beginSession();
EXPECT_THAT(br2.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
EXPECT_THAT(br2.error(), Eq(bitsery::ReaderError::InvalidData));
}
TEST(DataReadingErrors, WhenInitializingSessionsWhereSessionsDataOffsetIsCorruptedThenInvalidData) {
@@ -115,7 +115,7 @@ TEST(DataReadingErrors, WhenInitializingSessionsWhereSessionsDataOffsetIsCorrupt
bw.writeBytes<1>(uint8_t{1});
bw.writeBytes<1>(uint8_t{1});
bw.writeBytes<2>(uint16_t{10});
SessionsEnabledReader br{InputAdapter{buf.begin(), bw.getWrittenBytesCount()}};
SessionsEnabledReader br{InputAdapter{buf.begin(), bw.writtenBytesCount()}};
br.beginSession();
EXPECT_THAT(br.getError(), Eq(bitsery::ReaderError::INVALID_DATA));
EXPECT_THAT(br.error(), Eq(bitsery::ReaderError::InvalidData));
}

18
tests/buffer_writing.cpp → tests/data_writing.cpp
View File

@@ -32,7 +32,7 @@ using bitsery::EndiannessType;
template <typename BufType>
class DataWriting:public testing::Test {
public:
using TWriter = bitsery::BasicWriter<bitsery::DefaultConfig, bitsery::OutputBufferAdapter<BufType>>;
using TWriter = bitsery::AdapterWriter<bitsery::OutputBufferAdapter<BufType>, bitsery::DefaultConfig>;
using TBuffer = BufType;
};
@@ -63,7 +63,7 @@ TYPED_TEST(DataWriting, GetWrittenBytesCountReturnsActualBytesWritten) {
TWriter bw{buf};
writeData(bw);
bw.flush();
auto writtenSize = bw.getWrittenBytesCount();
auto writtenSize = bw.writtenBytesCount();
EXPECT_THAT(writtenSize, DATA_SIZE);
EXPECT_THAT(buf.size(), ::testing::Ge(DATA_SIZE));
}
@@ -73,11 +73,11 @@ TYPED_TEST(DataWriting, WhenWritingBitsThenMustFlushWriter) {
using TBuffer = typename TestFixture::TBuffer;
TBuffer buf{};
TWriter bw{buf};
bitsery::BitPackingWriter<TWriter> bpw{bw};
bitsery::AdapterWriterBitPackingWrapper<TWriter> bpw{bw};
bpw.writeBits(3u, 2);
auto writtenSize1 = bpw.getWrittenBytesCount();
auto writtenSize1 = bpw.writtenBytesCount();
bpw.flush();
auto writtenSize2 = bpw.getWrittenBytesCount();
auto writtenSize2 = bpw.writtenBytesCount();
EXPECT_THAT(writtenSize1, Eq(0));
EXPECT_THAT(writtenSize2, Eq(1));
}
@@ -87,12 +87,12 @@ TYPED_TEST(DataWriting, WhenDataAlignedThenFlushHasNoEffect) {
using TBuffer = typename TestFixture::TBuffer;
TBuffer buf{};
TWriter bw{buf};
bitsery::BitPackingWriter<TWriter> bpw{bw};
bitsery::AdapterWriterBitPackingWrapper<TWriter> bpw{bw};
bpw.writeBits(3u, 2);
bpw.align();
auto writtenSize1 = bpw.getWrittenBytesCount();
auto writtenSize1 = bpw.writtenBytesCount();
bpw.flush();
auto writtenSize2 = bpw.getWrittenBytesCount();
auto writtenSize2 = bpw.writtenBytesCount();
EXPECT_THAT(writtenSize1, Eq(1));
EXPECT_THAT(writtenSize2, Eq(1));
@@ -100,7 +100,7 @@ TYPED_TEST(DataWriting, WhenDataAlignedThenFlushHasNoEffect) {
TEST(DataWritingNonFixedBufferContainer, ContainerIsAlwaysResizedToCapacity) {
NonFixedContainer buf{};
bitsery::BasicWriter<bitsery::DefaultConfig, bitsery::OutputBufferAdapter<NonFixedContainer>> bw{buf};
bitsery::AdapterWriter<bitsery::OutputBufferAdapter<NonFixedContainer>, bitsery::DefaultConfig> bw{buf};
for (auto i = 0; i < 5; ++i) {
uint32_t tmp{};
bw.writeBytes<4>(tmp);

8
tests/flexible_syntax.cpp
View File

@@ -72,7 +72,7 @@ TEST(FlexibleSyntax, UseObjectFncInsteadOfValueN) {
double_t td = -454184.48445;
bool tb=true;
SerializationContext ctx;
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.object(ti);
ser.object(te);
ser.object(tf);
@@ -85,7 +85,7 @@ TEST(FlexibleSyntax, UseObjectFncInsteadOfValueN) {
float rf{};
double_t rd{};
bool rb{};
auto des = ctx.createDeserializer();
auto& des = ctx.createDeserializer();
des.object(ri);
des.object(re);
des.object(rf);
@@ -107,7 +107,7 @@ TEST(FlexibleSyntax, MixDifferentSyntax) {
double_t td = -454184.48445;
bool tb=true;
SerializationContext ctx;
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.value<sizeof(ti)>(ti);
ser.archive(te, tf, td);
ser.object(tb);
@@ -118,7 +118,7 @@ TEST(FlexibleSyntax, MixDifferentSyntax) {
float rf{};
double_t rd{};
bool rb{};
auto des = ctx.createDeserializer();
auto& des = ctx.createDeserializer();
des.archive(ri, re, rf);
des.value8b(rd);
des.object(rb);

18
tests/serialization_bool.cpp
View File

@@ -26,11 +26,9 @@
using testing::Eq;
template <bool BitPackingEnabled>
using Serializer = bitsery::BasicSerializer<Writer, BitPackingEnabled>;
using Serializer = bitsery::BasicSerializer<bitsery::AdapterWriterBitPackingWrapper<Writer>>;
template <bool BitPackingEnabled>
using Deserializer = bitsery::BasicDeserializer<Reader, BitPackingEnabled>;
using Deserializer = bitsery::BasicDeserializer<bitsery::AdapterReaderBitPackingWrapper<Reader>>;
TEST(SerializeBooleans, BoolAsBit) {
@@ -40,13 +38,13 @@ TEST(SerializeBooleans, BoolAsBit) {
bool t2{false};
bool res1;
bool res2;
auto ser = ctx.createSerializer();
ser.enableBitPacking([&t1, &t2](Serializer<true>& sbp) {
auto& ser = ctx.createSerializer();
ser.enableBitPacking([&t1, &t2](Serializer& sbp) {
sbp.boolValue(t1);
sbp.boolValue(t2);
});
auto des = ctx.createDeserializer();
des.enableBitPacking([&res1, &res2](Deserializer <true>& sbp) {
auto& des = ctx.createDeserializer();
des.enableBitPacking([&res1, &res2](Deserializer& sbp) {
sbp.boolValue(res1);
sbp.boolValue(res2);
});
@@ -62,10 +60,10 @@ TEST(SerializeBooleans, BoolAsByte) {
bool t2{false};
bool res1;
bool res2;
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.boolValue(t1);
ser.boolValue(t2);
auto des = ctx.createDeserializer();
auto& des = ctx.createDeserializer();
des.boolValue(res1);
des.boolValue(res2);

8
tests/serialization_container.cpp
View File

@@ -108,11 +108,11 @@ TYPED_TEST(SerializeContainerDynamicSizeArthmeticTypes, CustomFunctionIncrements
SerializationContext ctx{};
using TValue = typename TestFixture::TValue;
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.container(this->src, 1000, [&ser](TValue& v) {
ser.template value<sizeof(v)>(v);
});
auto des = ctx.createDeserializer();
auto& des = ctx.createDeserializer();
des.container(this->res, 1000, [&des](TValue &v) {
des.template value<sizeof(v)>(v);
//increment by 1 after reading
@@ -233,13 +233,13 @@ TYPED_TEST(SerializeContainerFixedSizeCompositeTypes, CustomFunctionThatSerializ
using TValue = decltype(*std::begin(res));
SerializationContext ctx;
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.container(src, [&ser](TValue &v) {
char tmp{};
ser.object(v);
ser.value1b(tmp);
});
auto des = ctx.createDeserializer();
auto& des = ctx.createDeserializer();
des.container(res, [&des](TValue &v) {
char tmp{};
des.object(v);

114
tests/serialization_ext_entropy.cpp
View File

@@ -30,22 +30,33 @@ using namespace testing;
using bitsery::ext::Entropy;
using BPSer = bitsery::BasicSerializer<bitsery::AdapterWriterBitPackingWrapper<Writer>>;
using BPDes = bitsery::BasicDeserializer<bitsery::AdapterReaderBitPackingWrapper<Reader>>;
TEST(SerializeExtensionEntropy, WhenEntropyEncodedThenOnlyWriteIndexUsingMinRequiredBits) {
int32_t v = 4849;
int32_t res;
constexpr size_t N = 3;
int32_t values[3] = {485,4849,89};
SerializationContext ctx;
ctx.createBPEnabledSerializer().ext4b(v, Entropy<int32_t[3]>{values});
ctx.createBPEnabledDeserializer().ext4b(res, Entropy<int32_t[3]>{values});
ctx.createSerializer().enableBitPacking([&v, &values](BPSer& ser) {
ser.ext4b(v, Entropy<int32_t[3]>{values});
});
ctx.createDeserializer().enableBitPacking([&res, &values](BPDes& des) {
des.ext4b(res, Entropy<int32_t[3]>{values});
});
EXPECT_THAT(res, Eq(v));
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
SerializationContext ctx1;
ctx1.createBPEnabledSerializer().ext4b(v, Entropy<int32_t[3]>{values});
auto des = ctx1.createBPEnabledDeserializer();
des.ext(res, bitsery::ext::ValueRange<int32_t>{0, static_cast<int32_t>(N + 1)});
ctx1.createSerializer().enableBitPacking([&v, &values](BPSer& ser) {
ser.ext4b(v, Entropy<int32_t[3]>{values});
});
ctx1.createDeserializer().enableBitPacking([&res](BPDes& des) {
des.ext(res, bitsery::ext::ValueRange<int32_t>{0, static_cast<int32_t>(N + 1)});
});
EXPECT_THAT(res, Eq(2));
}
@@ -54,8 +65,12 @@ TEST(SerializeExtensionEntropy, WhenNoEntropyEncodedThenWriteZeroBitsAndValueOrO
int16_t res;
std::initializer_list<int> values{485,4849,89};
SerializationContext ctx;
ctx.createBPEnabledSerializer().ext2b(v, Entropy<std::initializer_list<int>>{values});
ctx.createBPEnabledDeserializer().ext2b(res, Entropy<std::initializer_list<int>>{values});
ctx.createSerializer().enableBitPacking([&v, &values](BPSer& ser) {
ser.ext2b(v, Entropy<std::initializer_list<int>>{values});
});
ctx.createDeserializer().enableBitPacking([&res, &values](BPDes& des) {
des.ext2b(res, Entropy<std::initializer_list<int>>{values});
});
EXPECT_THAT(res, Eq(v));
EXPECT_THAT(ctx.getBufferSize(), Eq(sizeof(int16_t)+1));
@@ -70,9 +85,12 @@ TEST(SerializeExtensionEntropy, CustomTypeEntropyEncoded) {
MyStruct1{12, 10}, MyStruct1{485, 454},
MyStruct1{4849, 89}, MyStruct1{0, 1}};
SerializationContext ctx;
ctx.createBPEnabledSerializer().ext(v, Entropy<MyStruct1[N]>{values});
ctx.createBPEnabledDeserializer().ext(res, Entropy<MyStruct1[N]>{values});
ctx.createSerializer().enableBitPacking([&v, &values](BPSer& ser) {
ser.ext(v, Entropy<MyStruct1[N]>{values});
});
ctx.createDeserializer().enableBitPacking([&res, &values](BPDes& des) {
des.ext(res, Entropy<MyStruct1[N]>{values});
});
EXPECT_THAT(res, Eq(v));
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
}
@@ -85,9 +103,12 @@ TEST(SerializeExtensionEntropy, CustomTypeNotEntropyEncoded) {
MyStruct1{12,10}, MyStruct1{485, 454},
MyStruct1{4849,89}, MyStruct1{0,1}};
SerializationContext ctx;
ctx.createBPEnabledSerializer().ext(v, Entropy<std::initializer_list<MyStruct1>>{values});
ctx.createBPEnabledDeserializer().ext(res, Entropy<std::initializer_list<MyStruct1>>{values});
ctx.createSerializer().enableBitPacking([&v, &values](BPSer& ser) {
ser.ext(v, Entropy<std::initializer_list<MyStruct1>>{values});
});
ctx.createDeserializer().enableBitPacking([&res, &values](BPDes& des) {
des.ext(res, Entropy<std::initializer_list<MyStruct1>>{values});
});
EXPECT_THAT(res, Eq(v));
EXPECT_THAT(ctx.getBufferSize(), Eq(MyStruct1::SIZE + 1));
@@ -105,21 +126,22 @@ TEST(SerializeExtensionEntropy, CustomFunctionNotEntropyEncodedWithNoAlignBefore
auto rangeForValue = bitsery::ext::ValueRange<int>{0, 10000};
SerializationContext ctx;
auto& ser = ctx.createBPEnabledSerializer();
ctx.createSerializer().enableBitPacking([&v, &values, &rangeForValue](BPSer& ser){
//lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
auto serLambda = [&ser, &rangeForValue](MyStruct1& data) {
ser.ext(data.i1, rangeForValue);
ser.ext(data.i2, rangeForValue);
};
ser.ext(v, Entropy<std::vector<MyStruct1>>(values, false), serLambda);
});
//lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
auto serLambda = [&ser, &rangeForValue](MyStruct1& data) {
ser.ext(data.i1, rangeForValue);
ser.ext(data.i2, rangeForValue);
};
ser.ext(v, Entropy<std::vector<MyStruct1>>(values, false), serLambda);
auto des = ctx.createBPEnabledDeserializer();
auto desLambda = [&des, &rangeForValue](MyStruct1& data) {
des.ext(data.i1, rangeForValue);
des.ext(data.i2, rangeForValue);
};
des.ext(res, Entropy<std::vector<MyStruct1>>(values, false), desLambda);
ctx.createDeserializer().enableBitPacking([&res, &values, &rangeForValue](BPDes& des) {
auto desLambda = [&des, &rangeForValue](MyStruct1& data) {
des.ext(data.i1, rangeForValue);
des.ext(data.i2, rangeForValue);
};
des.ext(res, Entropy<std::vector<MyStruct1>>(values, false), desLambda);
});
EXPECT_THAT(res, Eq(v));
auto rangeForIndex = bitsery::ext::ValueRange<size_t>{0u, N+1};
@@ -137,21 +159,21 @@ TEST(SerializeExtensionEntropy, CustomFunctionNotEntropyEncodedWithAlignBeforeDa
auto rangeForValue = bitsery::ext::ValueRange<int>{0, 10000};
SerializationContext ctx;
auto& ser = ctx.createBPEnabledSerializer();
//lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
auto serLambda = [&ser, &rangeForValue](MyStruct1& data) {
ser.ext(data.i1, rangeForValue);
ser.ext(data.i2, rangeForValue);
};
ser.ext(v, Entropy<std::vector<MyStruct1>>(values, true), serLambda);
auto des = ctx.createBPEnabledDeserializer();
auto desLambda = [&des, &rangeForValue](MyStruct1& data) {
des.ext(data.i1, rangeForValue);
des.ext(data.i2, rangeForValue);
};
des.ext(res, Entropy<std::vector<MyStruct1>>(values, true), desLambda);
ctx.createSerializer().enableBitPacking([&v, &values, &rangeForValue](BPSer& ser){
//lambdas differ only in capture clauses, it would make sense to use std::bind, but debugger crashes when it sees std::bind...
auto serLambda = [&ser, &rangeForValue](MyStruct1& data) {
ser.ext(data.i1, rangeForValue);
ser.ext(data.i2, rangeForValue);
};
ser.ext(v, Entropy<std::vector<MyStruct1>>(values, true), serLambda);
});
ctx.createDeserializer().enableBitPacking([&res, &values, &rangeForValue](BPDes& des) {
auto desLambda = [&des, &rangeForValue](MyStruct1& data) {
des.ext(data.i1, rangeForValue);
des.ext(data.i2, rangeForValue);
};
des.ext(res, Entropy<std::vector<MyStruct1>>(values, true), desLambda);
});
EXPECT_THAT(res, Eq(v));
auto bitsForIndex = 8; //because aligned
@@ -166,8 +188,12 @@ TEST(SerializeExtensionEntropy, WhenEntropyEncodedThenCustomFunctionNotInvoked)
MyStruct1{4849,89}, MyStruct1{0,1}};
SerializationContext ctx;
ctx.createBPEnabledSerializer().ext(v, Entropy<std::list<MyStruct1>>{values}, [](MyStruct1& ) {});
ctx.createBPEnabledDeserializer().ext(res, Entropy<std::list<MyStruct1>>{values}, []( MyStruct1& ) {});
ctx.createSerializer().enableBitPacking([&v, &values](BPSer& ser) {
ser.ext(v, Entropy<std::list<MyStruct1>>{values}, [](MyStruct1& ) {});
});
ctx.createDeserializer().enableBitPacking([&res, &values](BPDes& des) {
des.ext(res, Entropy<std::list<MyStruct1>>{values}, []( MyStruct1& ) {});
});
EXPECT_THAT(res, Eq(v));
EXPECT_THAT(ctx.getBufferSize(), Eq(1));

4
tests/serialization_ext_growable.cpp
View File

@@ -60,7 +60,7 @@ TEST(SerializeExtensionGrowable, SessionDataConsistOfSessionsEndPosAnd4BytesSess
constexpr size_t DATA_SIZE = 4;
int32_t data{};
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.ext(data, Growable{}, [&ser](int32_t & v) { ser.value4b(v);});
ctx.createDeserializer();//to flush data and create buffer reader
@@ -78,7 +78,7 @@ TEST(SerializeExtensionGrowable, SessionDataConsistOfSessionsEndPosAnd4BytesSess
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 writtenSize = ctx.bw->writtenBytesCount();
auto dSize = writtenSize - sessionsOffset;
EXPECT_THAT(dSize, Eq(DATA_SIZE));
}

45
tests/serialization_ext_std_optional.cpp
View File

@@ -26,19 +26,17 @@
#if __cplusplus > 201402L
#include <bitsery/ext/value_range.h>
#include<optional>
#include <optional>
#include <bitsery/ext/std_optional.h>
#include <bitsery/ext/value_range.h>
using StdOptional = bitsery::ext::StdOptional;
using testing::Eq;
using BPSer = bitsery::BasicSerializer<Writer, true>;
using BPDes = bitsery::BasicDeserializer<Reader, true>;
template <typename T>
void test(SerializationContext& ctx, const T& v, T& r) {
@@ -83,16 +81,19 @@ TEST(SerializeExtensionStdOptional, OptionalHasValue) {
TEST(SerializeExtensionStdOptional, AlignAfterStateWriteRead) {
std::optional<int32_t> t1{43};
std::optional<int32_t> r1{52};
auto range = bitsery::ext::ValueRange<int>{40,60};
SerializationContext ctx;
auto& ser = ctx.createBPEnabledSerializer();
auto range = bitsery::ext::ValueRange<int>{40,60};
ser.ext(t1, StdOptional(true), [&ser, &range](int32_t& v) {
ser.ext(v, range);
ctx.createSerializer().enableBitPacking([&t1, &range](BPSer& ser) {
ser.ext(t1, StdOptional(true), [&ser, &range](int32_t& v) {
ser.ext(v, range);
});
});
auto des = ctx.createBPEnabledDeserializer();
des.ext(r1, StdOptional(true), [&des, &range](int32_t& v) {
des.ext(v, range);
ctx.createDeserializer().enableBitPacking([&r1, &range](BPDes& des) {
des.ext(r1, StdOptional(true), [&des, &range](int32_t& v) {
des.ext(v, range);
});
});
EXPECT_THAT(ctx.getBufferSize(), Eq(2));//1byte for index + 1byte for value
@@ -102,17 +103,21 @@ TEST(SerializeExtensionStdOptional, AlignAfterStateWriteRead) {
TEST(SerializeExtensionStdOptional, NoAlignAfterStateWriteRead) {
std::optional<int32_t> t1{43};
std::optional<int32_t> r1{52};
auto range = bitsery::ext::ValueRange<int>{40,60};
SerializationContext ctx;
auto& ser = ctx.createBPEnabledSerializer();
auto range = bitsery::ext::ValueRange<int>{40,60};
ser.ext(t1, StdOptional(false), [&ser, &range](int32_t& v) {
ser.ext(v, range);
ctx.createSerializer().enableBitPacking([&t1, &range](BPSer& ser) {
ser.ext(t1, StdOptional(false), [&ser, &range](int32_t& v) {
ser.ext(v, range);
});
});
auto des = ctx.createBPEnabledDeserializer();
des.ext(r1, StdOptional(false), [&des, &range](int32_t& v) {
des.ext(v, range);
ctx.createDeserializer().enableBitPacking([&r1, &range](BPDes& des) {
des.ext(r1, StdOptional(false), [&des, &range](int32_t& v) {
des.ext(v, range);
});
});
EXPECT_THAT(range.getRequiredBits() + 1, ::testing::Lt(8));
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
EXPECT_THAT(t1.value(), Eq(r1.value()));

4
tests/serialization_ext_std_set.cpp
View File

@@ -66,11 +66,11 @@ TEST(SerializeExtensionStdSet, FunctionSyntax) {
SerializationContext ctx1;
std::unordered_multiset<int32_t> t1{54,-484,841,79};
std::unordered_multiset<int32_t> r1{};
auto ser = ctx1.createSerializer();
auto& ser = ctx1.createSerializer();
ser.ext(t1, StdSet{10}, [&ser](int32_t& v) {
ser.value4b(v);
});
auto des = ctx1.createDeserializer();
auto& des = ctx1.createDeserializer();
des.ext(r1, StdSet{10}, [&des](int32_t& v) {
des.value4b(v);
});

74
tests/serialization_ext_value_range.cpp
View File

@@ -49,14 +49,21 @@ TEST(SerializeExtensionValueRange, RequiredBitsIsConstexpr) {
#endif
using BPSer = bitsery::BasicSerializer<bitsery::AdapterWriterBitPackingWrapper<Writer>>;
using BPDes = bitsery::BasicDeserializer<bitsery::AdapterReaderBitPackingWrapper<Reader>>;
TEST(SerializeExtensionValueRange, IntegerNegative) {
SerializationContext ctx;
ValueRange<int> r1{-50, 50};
int t1{-8};
int res1;
ctx.createBPEnabledSerializer().ext(t1, r1);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&t1, &r1](BPSer& ser) {
ser.ext(t1, r1);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
EXPECT_THAT(res1, Eq(t1));
@@ -69,8 +76,12 @@ TEST(SerializeExtensionValueRange, IntegerPositive) {
unsigned t1{8};
unsigned res1;
ctx.createBPEnabledSerializer().ext(t1, r1);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&t1, &r1](BPSer& ser) {
ser.ext(t1, r1);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
EXPECT_THAT(res1, Eq(t1));
@@ -83,8 +94,12 @@ TEST(SerializeExtensionValueRange, EnumTypes) {
MyEnumClass t1{MyEnumClass::E2};
MyEnumClass res1;
ctx.createBPEnabledSerializer().ext(t1, r1);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&t1, &r1](BPSer& ser) {
ser.ext(t1, r1);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
EXPECT_THAT(res1, Eq(t1));
@@ -101,8 +116,12 @@ TEST(SerializeExtensionValueRange, FloatUsingPrecisionConstraint1) {
float res1;
ctx.createBPEnabledSerializer().ext(t1, r1);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&t1, &r1](BPSer& ser) {
ser.ext(t1, r1);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
EXPECT_THAT(res1, ::testing::FloatNear(t1, (max - min) * precision));
@@ -118,8 +137,12 @@ TEST(SerializeExtensionValueRange, DoubleUsingPrecisionConstraint2) {
double res1;
ctx.createBPEnabledSerializer().ext(t1, r1);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&t1, &r1](BPSer& ser) {
ser.ext(t1, r1);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(5));
EXPECT_THAT(res1, ::testing::DoubleNear(t1, (max - min) * precision));
@@ -135,11 +158,15 @@ TEST(SerializeExtensionValueRange, FloatUsingBitsSizeConstraint1) {
float res1;
ctx.createBPEnabledSerializer().ext(t1, r1);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&t1, &r1](BPSer& ser) {
ser.ext(t1, r1);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
EXPECT_THAT(res1, ::testing::FloatNear(t1, (max - min) / (static_cast<bitsery::details::SAME_SIZE_UNSIGNED<float>>(1) << bits)));
EXPECT_THAT(res1, ::testing::FloatNear(t1, (max - min) / (static_cast<bitsery::details::SameSizeUnsigned<float>>(1) << bits)));
}
TEST(SerializeExtensionValueRange, DoubleUsingBitsSizeConstraint2) {
@@ -152,11 +179,15 @@ TEST(SerializeExtensionValueRange, DoubleUsingBitsSizeConstraint2) {
double res1;
ctx.createBPEnabledSerializer().ext(t1, r1);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&t1, &r1](BPSer& ser) {
ser.ext(t1, r1);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(7));
EXPECT_THAT(res1, ::testing::DoubleNear(t1, (max - min) / (static_cast<bitsery::details::SAME_SIZE_UNSIGNED<double>>(1) << bits)));
EXPECT_THAT(res1, ::testing::DoubleNear(t1, (max - min) / (static_cast<bitsery::details::SameSizeUnsigned<double>>(1) << bits)));
}
TEST(SerializeExtensionValueRange, WhenDataIsInvalidThenReturnMinimumRangeValue) {
@@ -164,8 +195,13 @@ TEST(SerializeExtensionValueRange, WhenDataIsInvalidThenReturnMinimumRangeValue)
ValueRange<int> r1{4, 10};//6 is max, but 3bits required
int res1;
uint8_t tmp{0xFF};//write all 1 so when reading 3 bits we get 7
ctx.createBPEnabledSerializer().value1b(tmp);
ctx.createBPEnabledDeserializer().ext(res1, r1);
ctx.createSerializer().enableBitPacking([&tmp](BPSer& ser) {
ser.value1b(tmp);
});
ctx.createDeserializer().enableBitPacking([&res1, &r1](BPDes& des) {
des.ext(res1, r1);
});
EXPECT_THAT(ctx.getBufferSize(), Eq(1));
EXPECT_THAT(res1, Eq(4));

4
tests/serialization_objects.cpp
View File

@@ -98,7 +98,7 @@ TEST(SerializeObject, GeneralConceptTest) {
z.x = X{ 234 };
auto ser = ctx.createSerializer();
auto& ser = ctx.createSerializer();
ser.object(y);
ser.object(z);
@@ -106,7 +106,7 @@ TEST(SerializeObject, GeneralConceptTest) {
Y yres{};
Z zres{};
auto des = ctx.createDeserializer();
auto& des = ctx.createDeserializer();
des.object(yres);
des.object(zres);

58
tests/serialization_test_utils.h
View File

@@ -27,7 +27,7 @@
#include <memory>
#include <bitsery/bitsery.h>
#include <bitsery/traits/vector.h>
#include <bitsery/adapters/buffer_adapters.h>
#include <bitsery/adapter/buffer.h>
/*
* define some types for testing
@@ -90,37 +90,44 @@ struct SessionsEnabledConfig: public bitsery::DefaultConfig {
static constexpr bool BufferSessionsEnabled = true;
};
using Buffer = std::vector<uint8_t>;
using Buffer = std::vector<char>;
using InputAdapter = bitsery::InputBufferAdapter<Buffer>;
using OutputAdapter = bitsery::OutputBufferAdapter<Buffer>;
using Writer = bitsery::BasicWriter<bitsery::DefaultConfig, OutputAdapter>;
using Reader = bitsery::BasicReader<bitsery::DefaultConfig, InputAdapter>;
using Writer = bitsery::AdapterWriter<OutputAdapter, bitsery::DefaultConfig>;
using Reader = bitsery::AdapterReader<InputAdapter, bitsery::DefaultConfig>;
template <typename Config = bitsery::DefaultConfig>
class BasicSerializationContext {
public:
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;
using TWriter = bitsery::AdapterWriter<OutputAdapter, Config>;
using TReader = bitsery::AdapterReader<InputAdapter, Config>;
std::unique_ptr<bitsery::BasicSerializer<TWriter>> ser;
std::unique_ptr<bitsery::BasicDeserializer<TReader>> des;
TWriter* bw;
TReader* br;
bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, false> createSerializer() {
//make_unique is not in c++11
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<TWriter>& createSerializer() {
if (!ser) {
ser = std::unique_ptr<bitsery::BasicSerializer<TWriter>>(new bitsery::BasicSerializer<TWriter>(OutputAdapter{buf}));
bw = &bitsery::AdapterAccess::getWriter(*ser);
}
return *ser;
};
bitsery::BasicSerializer<bitsery::BasicWriter<Config, OutputAdapter>, true>& createBPEnabledSerializer() {
//make_unique is not in c++11
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;
bitsery::BasicDeserializer<bitsery::AdapterReader<InputAdapter, Config>>& createDeserializer() {
bw->flush();
if (!des) {
des = std::unique_ptr<bitsery::BasicDeserializer<TReader>>(
new bitsery::BasicDeserializer<TReader>(InputAdapter{buf.begin(), bw->writtenBytesCount()}));
br = &bitsery::AdapterAccess::getReader(*des);
}
return *des;
};
size_t getBufferSize() const {
return bw->getWrittenBytesCount();
return bw->writtenBytesCount();
}
//since all containers .size() method returns size_t, it cannot be directly serialized, because size_t is platform dependant
@@ -133,21 +140,6 @@ public:
return 4;
}
bitsery::BasicDeserializer<bitsery::BasicReader<Config, InputAdapter>, false> createDeserializer() {
bw->flush();
//make_unique is not in c++11
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::BasicReader<Config, InputAdapter>, true> createBPEnabledDeserializer() {
sbp.reset(nullptr);
//make_unique is not in c++11
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