mirror of
https://github.com/fraillt/bitsery.git
synced 2026-06-11 17:53:55 +00:00
329 lines
11 KiB
C++
329 lines
11 KiB
C++
//MIT License
|
|
//
|
|
//Copyright (c) 2019 Mindaugas Vinkelis
|
|
//
|
|
//Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
//of this software and associated documentation files (the "Software"), to deal
|
|
//in the Software without restriction, including without limitation the rights
|
|
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
//copies of the Software, and to permit persons to whom the Software is
|
|
//furnished to do so, subject to the following conditions:
|
|
//
|
|
//The above copyright notice and this permission notice shall be included in all
|
|
//copies or substantial portions of the Software.
|
|
//
|
|
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
//SOFTWARE.
|
|
|
|
#include <forward_list>
|
|
#include <bitsery/traits/forward_list.h>
|
|
#include <bitsery/ext/std_set.h>
|
|
#include <bitsery/ext/std_map.h>
|
|
#include <bitsery/ext/pointer.h>
|
|
#include <bitsery/ext/std_smart_ptr.h>
|
|
|
|
#include <gmock/gmock.h>
|
|
#include "serialization_test_utils.h"
|
|
|
|
|
|
using testing::ContainerEq;
|
|
using testing::Eq;
|
|
|
|
//forward declare, for testing with std::unordered_map
|
|
class HasherForNonDefaultConstructible;
|
|
|
|
class NonDefaultConstructible {
|
|
int32_t i{0};
|
|
friend class HasherForNonDefaultConstructible;
|
|
|
|
|
|
|
|
|
|
friend class bitsery::Access;
|
|
NonDefaultConstructible() = default;
|
|
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.value4b(i);
|
|
}
|
|
|
|
public:
|
|
|
|
explicit NonDefaultConstructible(int32_t v):i{v} {}
|
|
|
|
bool operator == (const NonDefaultConstructible& other) const {
|
|
return i == other.i;
|
|
}
|
|
|
|
bool operator < (const NonDefaultConstructible& other) const {
|
|
return i < other.i;
|
|
}
|
|
};
|
|
|
|
class HasherForNonDefaultConstructible {
|
|
public:
|
|
size_t operator()(const NonDefaultConstructible& o) const {
|
|
return std::hash<int32_t>()(o.i);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
TEST(DeserializeNonDefaultConstructible, Container) {
|
|
SerializationContext ctx{};
|
|
std::vector<NonDefaultConstructible> data{};
|
|
data.emplace_back(1);
|
|
data.emplace_back(2);
|
|
data.emplace_back(3);
|
|
std::vector<NonDefaultConstructible> res{};
|
|
|
|
ctx.createSerializer().container(data, 10);
|
|
ctx.createDeserializer().container(res, 10);
|
|
|
|
EXPECT_THAT(res, ContainerEq(data));
|
|
}
|
|
//this test is here, because when object is not constructible we cannot simple "resize" container
|
|
TEST(DeserializeNonDefaultConstructible, ResultContainerShouldShrink) {
|
|
SerializationContext ctx{};
|
|
std::vector<NonDefaultConstructible> data{};
|
|
data.emplace_back(1);
|
|
std::vector<NonDefaultConstructible> res{};
|
|
res.emplace_back(2);
|
|
res.emplace_back(3);
|
|
|
|
ctx.createSerializer().container(data, 10);
|
|
ctx.createDeserializer().container(res, 10);
|
|
|
|
EXPECT_THAT(res, ContainerEq(data));
|
|
}
|
|
|
|
TEST(DeserializeNonDefaultConstructible, ResultStdForwardListShouldShrink) {
|
|
// forward list doesn't have .erase function, bet has erase_after
|
|
// in this case, if new size is 0 it must call clear, so we need to check two cases
|
|
{
|
|
// 1) when result should have more than 0 elements
|
|
SerializationContext ctx{};
|
|
std::forward_list<NonDefaultConstructible> data{};
|
|
data.push_front(NonDefaultConstructible{1});
|
|
std::forward_list<NonDefaultConstructible> res{};
|
|
res.push_front(NonDefaultConstructible{21});
|
|
res.push_front(NonDefaultConstructible{14});
|
|
|
|
ctx.createSerializer().container(data, 10);
|
|
ctx.createDeserializer().container(res, 10);
|
|
|
|
auto resIt = res.begin();
|
|
for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
|
|
EXPECT_THAT(*resIt, Eq(*it));
|
|
}
|
|
EXPECT_THAT(resIt, Eq(res.end()));
|
|
|
|
}
|
|
{
|
|
// 1) when result should have 0 elements
|
|
SerializationContext ctx{};
|
|
std::forward_list<NonDefaultConstructible> data{};
|
|
std::forward_list<NonDefaultConstructible> res{};
|
|
res.push_front(NonDefaultConstructible{1});
|
|
res.push_front(NonDefaultConstructible{14});
|
|
|
|
ctx.createSerializer().container(data, 10);
|
|
ctx.createDeserializer().container(res, 10);
|
|
|
|
EXPECT_THAT(res.begin(), Eq(res.end()));
|
|
|
|
}
|
|
}
|
|
|
|
TEST(DeserializeNonDefaultConstructible, StdSet) {
|
|
SerializationContext ctx{};
|
|
std::set<NonDefaultConstructible> data;
|
|
data.insert(NonDefaultConstructible{1});
|
|
data.insert(NonDefaultConstructible{2});
|
|
std::set<NonDefaultConstructible> res{};
|
|
data.insert(NonDefaultConstructible{3});
|
|
|
|
ctx.createSerializer().ext(data, bitsery::ext::StdSet{10});
|
|
ctx.createDeserializer().ext(res, bitsery::ext::StdSet{10});
|
|
|
|
EXPECT_THAT(res, ContainerEq(data));
|
|
}
|
|
|
|
TEST(DeserializeNonDefaultConstructible, StdMap) {
|
|
SerializationContext ctx{};
|
|
std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> data;
|
|
data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});
|
|
|
|
std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> res{};
|
|
data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});
|
|
data.emplace(NonDefaultConstructible{4}, NonDefaultConstructible{4});
|
|
|
|
auto& ser = ctx.createSerializer();
|
|
ser.ext(data, bitsery::ext::StdMap{10},[&ser](NonDefaultConstructible& key, NonDefaultConstructible& value) {
|
|
ser.object(key);
|
|
ser.object(value);
|
|
});
|
|
auto& des = ctx.createDeserializer();
|
|
des.ext(res, bitsery::ext::StdMap{10},[&des](NonDefaultConstructible& key, NonDefaultConstructible& value) {
|
|
des.object(key);
|
|
des.object(value);
|
|
});
|
|
|
|
EXPECT_THAT(res, ContainerEq(data));
|
|
}
|
|
|
|
|
|
struct NonPolymorphicPointers {
|
|
NonDefaultConstructible* pp;
|
|
std::unique_ptr<NonDefaultConstructible> up;
|
|
std::shared_ptr<NonDefaultConstructible> sp;
|
|
std::weak_ptr<NonDefaultConstructible> wp;
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, NonPolymorphicPointers& o) {
|
|
s.ext(o.pp, bitsery::ext::PointerOwner{});
|
|
s.ext(o.up, bitsery::ext::StdSmartPtr{});
|
|
s.ext(o.sp, bitsery::ext::StdSmartPtr{});
|
|
s.ext(o.wp, bitsery::ext::StdSmartPtr{});
|
|
}
|
|
|
|
TEST(DeserializeNonDefaultConstructible, NonPolymorphicPointerAndSmartPointer) {
|
|
using SerContext = BasicSerializationContext<bitsery::DefaultConfig, bitsery::ext::PointerLinkingContext>;
|
|
SerContext ctx{};
|
|
NonPolymorphicPointers data{};
|
|
data.pp = new NonDefaultConstructible{3};
|
|
data.up = std::unique_ptr<NonDefaultConstructible>(new NonDefaultConstructible{54});
|
|
data.sp = std::shared_ptr<NonDefaultConstructible>(new NonDefaultConstructible{-481});
|
|
data.wp = data.sp;
|
|
|
|
NonPolymorphicPointers res{};
|
|
bitsery::ext::PointerLinkingContext plctx1{};
|
|
ctx.createSerializer(&plctx1).object(data);
|
|
ctx.createDeserializer(&plctx1).object(res);
|
|
|
|
EXPECT_THAT(*res.pp, Eq(*data.pp));
|
|
delete res.pp;
|
|
delete data.pp;
|
|
EXPECT_THAT(*res.up, Eq(*data.up));
|
|
EXPECT_THAT(*res.sp, Eq(*data.sp));
|
|
EXPECT_THAT(*(res.wp.lock()), Eq(*(data.wp.lock())));
|
|
}
|
|
|
|
class PolymorphicNDCBase {
|
|
public:
|
|
virtual ~PolymorphicNDCBase() = 0;
|
|
template <typename S>
|
|
void serialize(S& ) {}
|
|
};
|
|
|
|
|
|
PolymorphicNDCBase::~PolymorphicNDCBase() = default;
|
|
|
|
class PolymorphicNDC1:public PolymorphicNDCBase {
|
|
int8_t i{};
|
|
friend class bitsery::Access;
|
|
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.value1b(i);
|
|
}
|
|
public:
|
|
PolymorphicNDC1() = default;
|
|
PolymorphicNDC1(int8_t v):i{v} {}
|
|
bool operator == (const PolymorphicNDC1& other) const {
|
|
return i == other.i;
|
|
}
|
|
};
|
|
|
|
class PolymorphicNDC2:public PolymorphicNDCBase {
|
|
uint16_t ui{};
|
|
|
|
friend class bitsery::Access;
|
|
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.value2b(ui);
|
|
}
|
|
public:
|
|
PolymorphicNDC2() = default;
|
|
PolymorphicNDC2(uint16_t v):ui{v} {}
|
|
bool operator == (const PolymorphicNDC2& other) const {
|
|
return ui == other.ui;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
namespace bitsery {
|
|
namespace ext {
|
|
|
|
template<>
|
|
struct PolymorphicBaseClass<PolymorphicNDCBase> : PolymorphicDerivedClasses<PolymorphicNDC1, PolymorphicNDC2> {
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
struct PolymorphicPointers {
|
|
PolymorphicNDCBase* pp;
|
|
std::unique_ptr<PolymorphicNDCBase> up;
|
|
std::shared_ptr<PolymorphicNDCBase> sp;
|
|
std::weak_ptr<PolymorphicNDCBase> wp;
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, PolymorphicPointers& o) {
|
|
s.ext(o.pp, bitsery::ext::PointerOwner{});
|
|
s.ext(o.up, bitsery::ext::StdSmartPtr{});
|
|
s.ext(o.sp, bitsery::ext::StdSmartPtr{});
|
|
s.ext(o.wp, bitsery::ext::StdSmartPtr{});
|
|
}
|
|
|
|
TEST(DeserializeNonDefaultConstructible, PolymorphicPointerAndSmartPointer) {
|
|
using TContext = std::tuple<bitsery::ext::PointerLinkingContext, bitsery::ext::PolymorphicContext<bitsery::ext::StandardRTTI>>;
|
|
using SerContext = BasicSerializationContext<bitsery::DefaultConfig, TContext>;
|
|
SerContext ctx{};
|
|
PolymorphicPointers data{};
|
|
data.pp = new PolymorphicNDC1{-4};
|
|
data.up = std::unique_ptr<PolymorphicNDCBase>(new PolymorphicNDC2{54});
|
|
data.sp = std::shared_ptr<PolymorphicNDCBase>(new PolymorphicNDC1{15});
|
|
data.wp = data.sp;
|
|
|
|
PolymorphicPointers res{};
|
|
TContext serCtx{};
|
|
std::get<1>(serCtx).registerBasesList<typename SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
|
|
TContext desCtx{};
|
|
std::get<1>(desCtx).registerBasesList<typename SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
|
|
|
|
ctx.createSerializer(&serCtx).object(data);
|
|
ctx.createDeserializer(&desCtx).object(res);
|
|
auto respp = dynamic_cast<PolymorphicNDC1*>(res.pp);
|
|
auto resup = dynamic_cast<PolymorphicNDC2*>(res.up.get());
|
|
auto ressp = dynamic_cast<PolymorphicNDC1*>(res.sp.get());
|
|
auto reswp = dynamic_cast<PolymorphicNDC1*>(res.wp.lock().get());
|
|
|
|
auto datapp = dynamic_cast<PolymorphicNDC1*>(data.pp);
|
|
auto dataup = dynamic_cast<PolymorphicNDC2*>(data.up.get());
|
|
auto datasp = dynamic_cast<PolymorphicNDC1*>(data.sp.get());
|
|
auto datawp = dynamic_cast<PolymorphicNDC1*>(data.wp.lock().get());
|
|
|
|
EXPECT_THAT(respp, ::testing::Ne(nullptr));
|
|
EXPECT_THAT(resup, ::testing::Ne(nullptr));
|
|
EXPECT_THAT(ressp, ::testing::Ne(nullptr));
|
|
EXPECT_THAT(reswp, ::testing::Ne(nullptr));
|
|
|
|
EXPECT_THAT(*respp, Eq(*datapp));
|
|
delete res.pp;
|
|
delete data.pp;
|
|
EXPECT_THAT(*resup, Eq(*dataup));
|
|
EXPECT_THAT(*ressp, Eq(*datasp));
|
|
EXPECT_THAT(*reswp, Eq(*datawp));
|
|
}
|