Scarfski/bitsery
1
0
Fork 0
mirror of https://github.com/fraillt/bitsery.git synced 2026-10-21 00:01:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

initial concept commit

Browse Source
This commit is contained in:
fraillt
2017-02-07 07:26:23 +02:00
commit 0fb7b0986d
16 changed files with 1533 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
tests/BufferBitsOpTests.cpp Normal file
View File

@@ -0,0 +1,107 @@
//
// Created by Mindaugas Vinkelis on 2017-01-10.
//
#include <gmock/gmock.h>
#include "BufferWriter.h"
#include "BufferReader.h"
using testing::Eq;
using testing::ContainerEq;
#include <list>
#include <bitset>
struct IntegralUnsignedTypes {
uint32_t a;
uint16_t b;
uint8_t c;
uint8_t d;
uint64_t e;
};
TEST(BufferBitsOperations, WriteAndReadBits) {
//setup data
IntegralUnsignedTypes data;
data.a = 485454;//bits 19
data.b = 45978;//bits 16
data.c = 0;//bits 1
data.d = 36;//bits 6
data.e = 479845648946;//bits 39
constexpr size_t aBITS = 21;
constexpr size_t bBITS = 16;
constexpr size_t cBITS = 5;
constexpr size_t dBITS = 7;
constexpr size_t eBITS = 40;
//create and write to buffer
std::vector<uint8_t> buf;
BufferWriter bw{buf};
bw.WriteBits<aBITS>(data.a);
bw.WriteBits<bBITS>(data.b);
bw.WriteBits<cBITS>(data.c);
bw.WriteBits<dBITS>(data.d);
bw.WriteBits<eBITS>(data.e);
bw.Flush();
auto bytesCount = ((aBITS + bBITS + cBITS + dBITS + eBITS) / 8) +1 ;
EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(bytesCount));
//read from buffer
BufferReader br{buf};
IntegralUnsignedTypes res;
br.ReadBits<aBITS>(res.a);
br.ReadBits<bBITS>(res.b);
br.ReadBits<cBITS>(res.c);
br.ReadBits<dBITS>(res.d);
br.ReadBits<eBITS>(res.e);
EXPECT_THAT(res.a, Eq(data.a));
EXPECT_THAT(res.b, Eq(data.b));
EXPECT_THAT(res.c, Eq(data.c));
EXPECT_THAT(res.d, Eq(data.d));
EXPECT_THAT(res.e, Eq(data.e));
}
TEST(BufferBitsOperations, WhenFinishedFlushWriter) {
std::vector<uint8_t> buf;
BufferWriter bw{buf};
bw.WriteBits<2>(0xFFu);
EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(0));
bw.Flush();
EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(1));
}
TEST(BufferBitsOperations, BufferSizeIsCountedPerByteNotPerBit) {
//setup data
//create and write to buffer
std::vector<uint8_t> buf;
BufferWriter bw{buf};
bw.WriteBits<2>(0xFFu);
bw.Flush();
EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(1));
//read from buffer
BufferReader br{buf};
unsigned tmp;
EXPECT_THAT(br.ReadBits<4>(tmp), Eq(true));
EXPECT_THAT(br.ReadBits<2>(tmp), Eq(true));
EXPECT_THAT(br.ReadBits<2>(tmp), Eq(true));
EXPECT_THAT(br.ReadBits<2>(tmp), Eq(false));
//part of next byte
BufferReader br1{buf};
EXPECT_THAT(br1.ReadBits<2>(tmp), Eq(true));
EXPECT_THAT(br1.ReadBits<7>(tmp), Eq(false));
//bigger than byte
BufferReader br2{buf};
EXPECT_THAT(br2.ReadBits<9>(tmp), Eq(false));
}

129
tests/BufferBytesOpTests.cpp Normal file
View File

@@ -0,0 +1,129 @@
//
// Created by Mindaugas Vinkelis on 2016-11-11.
//
#include <gmock/gmock.h>
#include "BufferWriter.h"
#include "BufferReader.h"
using testing::Eq;
using testing::ContainerEq;
#include <list>
#include <bitset>
struct IntegralTypes {
int64_t a;
uint32_t b;
int16_t c;
uint8_t d;
int8_t e;
int8_t f[2];
};
TEST(BufferBytesOperations, WriteAndReadBytes) {
//setup data
IntegralTypes data;
data.a = -4894541654564;
data.b = 94545646;
data.c = -8778;
data.d = 200;
data.e = -98;
data.f[0] = 43;
data.f[1] = -45;
//create and write to buffer
std::vector<uint8_t> buf{};
BufferWriter bw{buf};
bw.WriteBytes<4>(data.b);
bw.WriteBytes<1>(data.f[0]);
bw.WriteBytes<2>(data.c);
bw.WriteBytes<1>(data.d);
bw.WriteBytes<8>(data.a);
bw.WriteBytes<1>(data.e);
bw.WriteBytes<1>(data.f[1]);
EXPECT_THAT(std::distance(buf.begin(), buf.end()), Eq(18));
//read from buffer
BufferReader br{buf};
IntegralTypes res{};
EXPECT_THAT(br.ReadBytes<4>(res.b), Eq(true));
EXPECT_THAT(br.ReadBytes<1>(res.f[0]), Eq(true));
EXPECT_THAT(br.ReadBytes<2>(res.c), Eq(true));
EXPECT_THAT(br.ReadBytes<1>(res.d), Eq(true));
EXPECT_THAT(br.ReadBytes<8>(res.a), Eq(true));
EXPECT_THAT(br.ReadBytes<1>(res.e), Eq(true));
EXPECT_THAT(br.ReadBytes<1>(res.f[1]), Eq(true));
//assert results
EXPECT_THAT(data.a, Eq(res.a));
EXPECT_THAT(data.b, Eq(res.b));
EXPECT_THAT(data.c, Eq(res.c));
EXPECT_THAT(data.d, Eq(res.d));
EXPECT_THAT(data.e, Eq(res.e));
EXPECT_THAT(data.f, ContainerEq(res.f));
}
TEST(BufferBytesOperations, ReadReturnsFalseIfNotEnoughBufferSize) {
//setup data
uint8_t a = 111;
//create and write to buffer
std::vector<uint8_t> buf{};
BufferWriter bw{buf};
bw.WriteBytes<1>(a);
bw.WriteBytes<1>(a);
bw.WriteBytes<1>(a);
//read from buffer
BufferReader br{buf};
int16_t b;
int32_t c;
EXPECT_THAT(br.ReadBytes<4>(c), Eq(false));
EXPECT_THAT(br.ReadBytes<2>(b), Eq(true));
EXPECT_THAT(br.ReadBytes<2>(b), Eq(false));
EXPECT_THAT(br.ReadBytes<1>(a), Eq(true));
EXPECT_THAT(br.ReadBytes<1>(a), Eq(false));
EXPECT_THAT(br.ReadBytes<2>(b), Eq(false));
EXPECT_THAT(br.ReadBytes<4>(c), Eq(false));
}
TEST(BufferBytesOperations, ReadIsCompletedWhenAllBytesAreRead) {
//setup data
IntegralTypes data;
data.b = 94545646;
data.c = -8778;
data.d = 200;
//create and write to buffer
std::vector<uint8_t> buf{};
BufferWriter bw{buf};
bw.WriteBytes<4>(data.b);
bw.WriteBytes<2>(data.c);
bw.WriteBytes<1>(data.d);
//read from buffer
BufferReader br{buf};
IntegralTypes res;
EXPECT_THAT(br.ReadBytes<4>(res.b), Eq(true));
EXPECT_THAT(br.ReadBytes<2>(res.c), Eq(true));
EXPECT_THAT(br.isCompleted(), Eq(false));
EXPECT_THAT(br.ReadBytes<1>(res.d), Eq(true));
EXPECT_THAT(br.isCompleted(), Eq(true));
EXPECT_THAT(br.ReadBytes<1>(res.d), Eq(false));
EXPECT_THAT(br.isCompleted(), Eq(true));
BufferReader br1{buf};
EXPECT_THAT(br1.ReadBytes<4>(res.b), Eq(true));
EXPECT_THAT(br1.ReadBytes<2>(res.c), Eq(true));
EXPECT_THAT(br1.isCompleted(), Eq(false));
EXPECT_THAT(br1.ReadBytes<2>(res.c), Eq(false));
EXPECT_THAT(br1.isCompleted(), Eq(false));
EXPECT_THAT(br1.ReadBytes<1>(res.d), Eq(true));
EXPECT_THAT(br1.isCompleted(), Eq(true));
}

50
tests/CMakeLists.txt Normal file
View File

@@ -0,0 +1,50 @@
cmake_minimum_required(VERSION 3.2)
set(PROJECT_TEST_NAME serialization_tests)
project(${PROJECT_TEST_NAME} C CXX)
find_package(Threads REQUIRED)
#add googletest external project
#USE_GMOCK enable gmock
#exports variables GTEST_INCLUDE_DIRS, GTEST_LIBS_DIR, GTEST_LIBNAME, GTEST_MAIN_LIBNAME
set(EXT_PROJECTS_DIR ${CMAKE_SOURCE_DIR}/ext)
set(USE_GMOCK ON)
add_subdirectory(${EXT_PROJECTS_DIR}/gtest ${CMAKE_BINARY_DIR}/gtest)
# set common include folder for module
include_directories(SYSTEM ${GTEST_INCLUDE_DIRS})
include_directories(${CMAKE_SOURCE_DIR}/include)
file(GLOB TEST_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
add_executable(${PROJECT_TEST_NAME} ${TEST_SRC_FILES})
add_dependencies(${PROJECT_TEST_NAME} googletest)
set_property(TARGET ${PROJECT_TEST_NAME} PROPERTY CXX_STANDARD 14)
set_property(TARGET ${PROJECT_TEST_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
if(NOT WIN32 OR MINGW)
FOREACH(LIBNAME ${GTEST_LINK_LIBNAMES})
target_link_libraries(${PROJECT_TEST_NAME} ${GTEST_LIBS_DIR}/lib${LIBNAME}.a )
ENDFOREACH()
else()
FOREACH(LIBNAME ${GTEST_LINK_LIBNAMES})
target_link_libraries(${PROJECT_TEST_NAME}
debug ${GTEST_LIBS_DIR}/DebugLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LIBNAME}${CMAKE_FIND_LIBRARY_SUFFIXES}
optimized ${GTEST_LIBS_DIR}/ReleaseLibs/${CMAKE_FIND_LIBRARY_PREFIXES}${LIBNAME}${CMAKE_FIND_LIBRARY_SUFFIXES})
ENDFOREACH()
endif()
target_link_libraries(${PROJECT_TEST_NAME} ${CMAKE_THREAD_LIBS_INIT})
add_test(NAME all_tests COMMAND $<TARGET_FILE:${PROJECT_TEST_NAME}>)

160
tests/SerializerObjectsTests.cpp Normal file
View File

@@ -0,0 +1,160 @@
//
// Created by fraillt on 17.1.31.
//
#include <gmock/gmock.h>
#include <Deserializer.h>
#include <BufferReader.h>
#include "BufferWriter.h"
#include "Serializer.h"
#include "DeltaSerializer.h"
#include "DeltaDeserializer.h"
#include <list>
#include <array>
using testing::Eq;
using testing::StrEq;
using testing::ContainerEq;
struct X {
X() {};
X(int v) :x{ v } {}
std::string s{};
int x{};
bool operator ==(const X& r) const {
return r.x == x && r.s == s;
}
};
struct Y {
int y{};
int carr[3];
std::array<int, 3> arr;
std::vector<X> vx;
std::string s;
};
struct Z { X x{}; Y y{}; };
SERIALIZE(Z)
{
s.object(o.x);
s.object(o.y);
return s;
}
SERIALIZE(X)
{
return s.value(o.x)
.text(o.s);
}
SERIALIZE(Y)
{
auto writeInt = [&s](auto& v) { s.template value<4>(v); };
s.text(o.s);
s.template value<4>(o.y);
s.withArray(o.arr, writeInt);
s.withArray(o.carr, writeInt);
s.withContainer(o.vx, [&s](auto& v) { s.object(v); });
return s;
}
TEST(Serializer, GeneralConceptTest) {
//std::string buf;
std::vector<uint8_t> buf{};
BufferWriter bw{ buf };
Serializer<BufferWriter> ser(bw);
Y y{};
y.y = 3423;
y.arr[0] = 111;
y.arr[1] = 222;
y.arr[2] = 333;
y.carr[0] = 123;
y.carr[1] = 456;
y.carr[2] = 789;
y.vx.push_back(X(234));
y.vx.push_back(X(6245));
y.vx.push_back(X(613461));
y.s = "labal diena";
Z z{};
z.y = y;
z.x = X{ 234 };
serialize(ser, y);
serialize(ser, z);
BufferReader br{ buf };
Deserializer<BufferReader> des(br);
Y yres{};
Z zres{};
serialize(des, yres);
serialize(des, zres);
EXPECT_THAT(yres.y, Eq(y.y));
EXPECT_THAT(yres.vx, ContainerEq(y.vx));
EXPECT_THAT(yres.arr, ContainerEq(y.arr));
EXPECT_THAT(yres.carr, ContainerEq(y.carr));
EXPECT_THAT(yres.s, StrEq(y.s));
EXPECT_THAT(zres.y.y, Eq(z.y.y));
EXPECT_THAT(zres.y.vx, ContainerEq(z.y.vx));
EXPECT_THAT(zres.y.arr, ContainerEq(z.y.arr));
EXPECT_THAT(zres.y.carr, ContainerEq(z.y.carr));
EXPECT_THAT(zres.y.s, StrEq(z.y.s));
EXPECT_THAT(zres.x.s, StrEq(z.x.s));
EXPECT_THAT(zres.x.x, Eq(z.x.x));
}
TEST(DeltaSerializer, GeneralConceptTest) {
//std::string buf;
Y y{};
y.y = 3423;
y.arr[0] = 111;
y.arr[1] = 222;
y.arr[2] = 333;
y.carr[0] = 123;
y.carr[1] = 456;
y.carr[2] = 789;
y.vx.push_back(X(234));
y.vx.push_back(X(6245));
y.vx.push_back(X(613461));
y.s = "labal diena";
y.vx[0].s = "very nice";
y.vx[1].s = "very nice string, that is a little bit longer that previous";
Y yRead = y;
Y yNew = y;
yNew.y = 111111;
yNew.arr[2] = 0xFFFFFFFF;
yNew.carr[1] = 0xFFFFFFFF;
yNew.s = "labas dienaABC";
yNew.vx[0].s = "very nigga";
yNew.vx[1].s = "bla";
yNew.vx.push_back(X{ 3 });
std::vector<uint8_t> buf;
BufferWriter bw{ buf };
DeltaSerializer<BufferWriter, Y> ser(bw, y, yNew);
serialize(ser, yNew);
bw.Flush();
BufferReader br{ buf };
DeltaDeserializer<BufferReader, Y> des(br, y, yRead);
serialize(des, yRead);
EXPECT_THAT(yRead.y, Eq(yNew.y));
EXPECT_THAT(yRead.vx, ContainerEq(yNew.vx));
EXPECT_THAT(yRead.arr, ContainerEq(yNew.arr));
EXPECT_THAT(yRead.carr, ContainerEq(yNew.carr));
EXPECT_THAT(yRead.s, StrEq(yNew.s));
}

55
tests/SerializerValuesTests.cpp Normal file
View File

@@ -0,0 +1,55 @@
//
// Created by fraillt on 17.1.5.
//
#include <gmock/gmock.h>
#include <Deserializer.h>
#include <BufferReader.h>
#include "BufferWriter.h"
#include "Serializer.h"
using testing::Eq;
template <typename T>
bool SerializeDeserializeValue(const T& v) {
T res{};
std::vector<uint8_t> buf{};
BufferWriter bw{buf};
Serializer<BufferWriter> ser(bw);
ser.value(v);
bw.Flush();
BufferReader br{buf};
Deserializer<BufferReader> des(br);
des.value(res);
return v == res;
}
TEST(SerializerValues, IntegerTypes) {
EXPECT_THAT(SerializeDeserializeValue(-449874), Eq(true));
EXPECT_THAT(SerializeDeserializeValue(34u), Eq(true));
}
TEST(SerializerValues, EnumTypes) {
enum E1{
A1,B1,C1,D1
};
EXPECT_THAT(SerializeDeserializeValue(E1::C1), Eq(true));
enum class E2 {
A2,B2,C2,D2
};
EXPECT_THAT(SerializeDeserializeValue(E2::B2), Eq(true));
enum class E3:short {
A3, B3, C3=4568, D3
};
EXPECT_THAT(SerializeDeserializeValue(E3::C3), Eq(true));
}
TEST(SerializerValues, FloatingPointTypes) {
EXPECT_THAT(SerializeDeserializeValue(-484.465), Eq(true));
EXPECT_THAT(SerializeDeserializeValue(0.00000015f), Eq(true));
}