mirror of
https://github.com/fraillt/bitsery.git
synced 2026-06-09 16:53:55 +00:00
395 lines
11 KiB
C++
395 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 <bitsery/ext/pointer.h>
|
|
#include <bitsery/ext/std_map.h>
|
|
#include <bitsery/ext/std_set.h>
|
|
#include <bitsery/ext/std_smart_ptr.h>
|
|
#include <bitsery/traits/forward_list.h>
|
|
#include <forward_list>
|
|
|
|
#include "serialization_test_utils.h"
|
|
#include <gmock/gmock.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);
|
|
res.emplace_back(4);
|
|
|
|
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()));
|
|
}
|
|
|
|
{
|
|
// also check if correctly expands if source is bigger than destination
|
|
SerializationContext ctx{};
|
|
std::forward_list<NonDefaultConstructible> data{};
|
|
data.push_front(NonDefaultConstructible{ 1 });
|
|
data.push_front(NonDefaultConstructible{ 14 });
|
|
std::forward_list<NonDefaultConstructible> res{};
|
|
|
|
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()));
|
|
}
|
|
}
|
|
|
|
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 },
|
|
[](decltype(ser)& ser,
|
|
NonDefaultConstructible& key,
|
|
NonDefaultConstructible& value) {
|
|
ser.object(key);
|
|
ser.object(value);
|
|
});
|
|
auto& des = ctx.createDeserializer();
|
|
des.ext(res,
|
|
bitsery::ext::StdMap{ 10 },
|
|
[](decltype(des)& 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::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<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{};
|
|
TContext desCtx{};
|
|
|
|
std::get<1>(serCtx).registerBasesList<typename SerContext::TSerializer>(
|
|
bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
|
|
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));
|
|
std::get<0>(serCtx).clearSharedState();
|
|
std::get<0>(desCtx).clearSharedState();
|
|
}
|