mirror of
https://github.com/fraillt/bitsery.git
synced 2026-06-08 00:03:54 +00:00
355 lines
9.7 KiB
C++
355 lines
9.7 KiB
C++
//MIT License
|
|
//
|
|
//Copyright (c) 2017 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/inheritance.h>
|
|
#include <gmock/gmock.h>
|
|
#include "serialization_test_utils.h"
|
|
|
|
using bitsery::ext::BaseClass;
|
|
using bitsery::ext::VirtualBaseClass;
|
|
|
|
struct ConfigWithInheritanceCtx:bitsery::DefaultConfig {
|
|
using InternalContext = std::tuple<bitsery::ext::InheritanceContext>;
|
|
};
|
|
|
|
using SerContext = BasicSerializationContext<ConfigWithInheritanceCtx, void>;
|
|
|
|
using testing::Eq;
|
|
|
|
/*
|
|
* base class
|
|
*/
|
|
struct Base {
|
|
uint8_t x{};
|
|
virtual ~Base() = default;
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, Base& o) {
|
|
s.value1b(o.x);
|
|
}
|
|
|
|
/*
|
|
* non virtual inheritance from base
|
|
*/
|
|
struct Derive1NonVirtually:Base {
|
|
uint8_t y1{};
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, Derive1NonVirtually& o) {
|
|
s.ext(o, BaseClass<Base>{});
|
|
s.value1b(o.y1);
|
|
}
|
|
|
|
struct Derive2NonVirtually:Base {
|
|
uint8_t y2{};
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, Derive2NonVirtually& o) {
|
|
//use lambda to serialize base
|
|
s.ext(o, BaseClass<Base>{}, [&s](Base& b) {
|
|
s.object(b);
|
|
});
|
|
s.value1b(o.y2);
|
|
}
|
|
|
|
struct MultipleInheritanceNonVirtualBase: Derive1NonVirtually, Derive2NonVirtually {
|
|
uint8_t z{};
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, MultipleInheritanceNonVirtualBase& o) {
|
|
s.ext(o, BaseClass<Derive1NonVirtually>{});
|
|
s.ext(o, BaseClass<Derive2NonVirtually>{});
|
|
s.value1b(o.z);
|
|
}
|
|
|
|
/*
|
|
* virtual inheritance from base
|
|
*/
|
|
struct Derive1Virtually:virtual Base {
|
|
uint8_t y1{};
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, Derive1Virtually& o) {
|
|
s.ext(o, VirtualBaseClass<Base>{});
|
|
s.value1b(o.y1);
|
|
}
|
|
|
|
struct Derive2Virtually:virtual Base {
|
|
uint8_t y2{};
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, Derive2Virtually& o) {
|
|
s.ext(o, VirtualBaseClass<Base>{});
|
|
s.value1b(o.y2);
|
|
}
|
|
|
|
struct MultipleInheritanceVirtualBase: Derive1Virtually, Derive2Virtually {
|
|
uint8_t z{};
|
|
MultipleInheritanceVirtualBase() = default;
|
|
|
|
MultipleInheritanceVirtualBase(uint8_t x_, uint8_t y1_, uint8_t y2_, uint8_t z_) {
|
|
x = x_;
|
|
y1 = y1_;
|
|
y2 = y2_;
|
|
z = z_;
|
|
}
|
|
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.ext(*this, BaseClass<Derive1Virtually>{});
|
|
s.ext(*this, BaseClass<Derive2Virtually>{});
|
|
s.value1b(z);
|
|
}
|
|
|
|
};
|
|
|
|
bool operator == (const MultipleInheritanceVirtualBase& lhs, const MultipleInheritanceVirtualBase& rhs) {
|
|
return std::tie(lhs.x, lhs.y1, lhs.y2, lhs.z) == std::tie(rhs.x, rhs.y1, rhs.y2, rhs.z);
|
|
}
|
|
|
|
TEST(SerializeExtensionInheritance, BaseClass) {
|
|
|
|
Derive1NonVirtually d1{};
|
|
d1.x = 187;
|
|
d1.y1 = 74;
|
|
Derive1NonVirtually rd1{};
|
|
|
|
SerContext ctx{};
|
|
ctx.createSerializer().object(d1);
|
|
ctx.createDeserializer().object(rd1);
|
|
|
|
EXPECT_THAT(rd1.x, Eq(d1.x));
|
|
EXPECT_THAT(rd1.y1, Eq(d1.y1));
|
|
EXPECT_THAT(ctx.getBufferSize(), Eq(2));
|
|
}
|
|
|
|
TEST(SerializeExtensionInheritance, VirtualBaseClass) {
|
|
Derive1Virtually d1{};
|
|
d1.x = 15;
|
|
d1.y1 = 87;
|
|
Derive1Virtually rd1{};
|
|
|
|
SerContext ctx{};
|
|
ctx.createSerializer().object(d1);
|
|
ctx.createDeserializer().object(rd1);
|
|
|
|
EXPECT_THAT(rd1.x, Eq(d1.x));
|
|
EXPECT_THAT(rd1.y1, Eq(d1.y1));
|
|
EXPECT_THAT(ctx.getBufferSize(), Eq(2));
|
|
}
|
|
|
|
TEST(SerializeExtensionInheritance, MultipleBasesWithoutVirtualInheritance) {
|
|
MultipleInheritanceNonVirtualBase md{};
|
|
//x is ambiguous because we don't derive virtually
|
|
static_cast<Derive1NonVirtually&>(md).x = 1;
|
|
static_cast<Derive2NonVirtually&>(md).x = 2;
|
|
md.y1 = 4;
|
|
md.z = 5;
|
|
md.y2 = 6;
|
|
MultipleInheritanceNonVirtualBase res{};
|
|
|
|
SerContext ctx{};
|
|
ctx.createSerializer().object(md);
|
|
ctx.createDeserializer().object(res);
|
|
|
|
EXPECT_THAT(static_cast<Derive1NonVirtually&>(res).x, Eq(static_cast<Derive1NonVirtually&>(md).x));
|
|
EXPECT_THAT(static_cast<Derive2NonVirtually&>(res).x, Eq(static_cast<Derive2NonVirtually&>(md).x));
|
|
EXPECT_THAT(res.y1, Eq(md.y1));
|
|
EXPECT_THAT(res.y2, Eq(md.y2));
|
|
EXPECT_THAT(res.z, Eq(md.z));
|
|
EXPECT_THAT(ctx.getBufferSize(), Eq(5)); //5 because two bases
|
|
|
|
}
|
|
|
|
TEST(SerializeExtensionInheritance, WhenNoVirtualInheritanceExistsThenInheritanceContextIsNotRequired) {
|
|
MultipleInheritanceNonVirtualBase md{};
|
|
//x is ambiguous because we don't derive virtually
|
|
static_cast<Derive1NonVirtually&>(md).x = 1;
|
|
static_cast<Derive2NonVirtually&>(md).x = 2;
|
|
md.y1 = 4;
|
|
md.z = 5;
|
|
md.y2 = 6;
|
|
MultipleInheritanceNonVirtualBase res{};
|
|
|
|
//without InheritanceContext
|
|
SerializationContext ctx{};
|
|
ctx.createSerializer().object(md);
|
|
ctx.createDeserializer().object(res);
|
|
|
|
EXPECT_THAT(static_cast<Derive1NonVirtually&>(res).x, Eq(static_cast<Derive1NonVirtually&>(md).x));
|
|
EXPECT_THAT(static_cast<Derive2NonVirtually&>(res).x, Eq(static_cast<Derive2NonVirtually&>(md).x));
|
|
EXPECT_THAT(res.y1, Eq(md.y1));
|
|
EXPECT_THAT(res.y2, Eq(md.y2));
|
|
EXPECT_THAT(res.z, Eq(md.z));
|
|
EXPECT_THAT(ctx.getBufferSize(), Eq(5)); //5 because two bases
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(SerializeExtensionInheritance, MultipleBasesWithVirtualInheritance) {
|
|
MultipleInheritanceVirtualBase md{3,7,5,15};
|
|
MultipleInheritanceVirtualBase res{};
|
|
|
|
SerContext ctx{};
|
|
ctx.createSerializer().object(md);
|
|
ctx.createDeserializer().object(res);
|
|
EXPECT_THAT(res, Eq(md));
|
|
EXPECT_THAT(ctx.getBufferSize(), Eq(4)); //4 because virtual base
|
|
}
|
|
|
|
TEST(SerializeExtensionInheritance, MultipleBasesWithVirtualInheritanceMultipleObjects) {
|
|
std::vector<MultipleInheritanceVirtualBase> data;
|
|
data.emplace_back(4,8,7,9);
|
|
data.emplace_back(1,2,3,4);
|
|
data.emplace_back(8,7,15,97);
|
|
data.emplace_back(54,132,45,84);
|
|
data.emplace_back(27,85,41,2);
|
|
std::vector<MultipleInheritanceVirtualBase> res{};
|
|
|
|
SerContext ctx{};
|
|
ctx.createSerializer().container(data, 10);
|
|
ctx.createDeserializer().container(res, 10);
|
|
EXPECT_THAT(res, ::testing::ContainerEq(data));
|
|
EXPECT_THAT(ctx.getBufferSize(), Eq(1 + 4 * data.size())); //1 container size + 4 because virtual base * elements
|
|
}
|
|
|
|
//
|
|
class BasePrivateSerialize {
|
|
public:
|
|
explicit BasePrivateSerialize(uint8_t v):_v{v} {}
|
|
uint8_t getX() const { return _v; }
|
|
private:
|
|
uint8_t _v;
|
|
|
|
friend bitsery::Access;
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.value1b(_v);
|
|
}
|
|
|
|
};
|
|
|
|
class DerivedPrivateBase: public BasePrivateSerialize {
|
|
public:
|
|
explicit DerivedPrivateBase(uint8_t v) : BasePrivateSerialize(v) {}
|
|
uint8_t z{};
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, DerivedPrivateBase& o) {
|
|
//use lambda for base serialization
|
|
s.ext(o, BaseClass<BasePrivateSerialize>{}, [&s](BasePrivateSerialize& b) {
|
|
s.object(b);
|
|
});
|
|
s.value1b(o.z);
|
|
}
|
|
|
|
struct BaseNonMemberSerialize {
|
|
uint8_t x{};
|
|
};
|
|
|
|
template <typename S>
|
|
void serialize(S& s, BaseNonMemberSerialize& o) {
|
|
s.value1b(o.x);
|
|
}
|
|
|
|
|
|
struct DerivedMemberSerialize: public BaseNonMemberSerialize {
|
|
uint8_t z{};
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.ext(*this, BaseClass<BaseNonMemberSerialize>{});
|
|
s.value1b(z);
|
|
}
|
|
};
|
|
|
|
//explicitly select serialize functions, for types that has ambiguous serialize functions
|
|
namespace bitsery {
|
|
template <>
|
|
struct SelectSerializeFnc<DerivedPrivateBase>:UseNonMemberFnc {};
|
|
|
|
template <>
|
|
struct SelectSerializeFnc<DerivedMemberSerialize>:UseMemberFnc {};
|
|
}
|
|
|
|
|
|
TEST(SerializeExtensionInheritance, WhenDerivedClassHasAmbiguousSerializeFunctionThenExplicitlySelectSpecialization) {
|
|
DerivedPrivateBase data1{43};
|
|
data1.z = 87;
|
|
DerivedMemberSerialize data2{};
|
|
data2.x = 71;
|
|
data2.z = 22;
|
|
DerivedPrivateBase res1{0};
|
|
DerivedMemberSerialize res2{};
|
|
|
|
SerContext ctx{};
|
|
ctx.createSerializer().object(data1);
|
|
ctx.createSerializer().object(data2);
|
|
ctx.createDeserializer().object(res1);
|
|
ctx.createDeserializer().object(res2);
|
|
EXPECT_THAT(res1.getX(), Eq(data1.getX()));
|
|
EXPECT_THAT(res1.z, Eq(data1.z));
|
|
EXPECT_THAT(res2.x, Eq(data2.x));
|
|
EXPECT_THAT(res2.z, Eq(data2.z));
|
|
}
|
|
|
|
struct AbstractBase {
|
|
uint8_t x{};
|
|
virtual void exec() = 0;
|
|
virtual ~AbstractBase() = default;
|
|
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.value1b(x);
|
|
}
|
|
};
|
|
|
|
struct ImplementedBase:AbstractBase {
|
|
uint8_t y{};
|
|
void exec() override {}
|
|
|
|
template <typename S>
|
|
void serialize(S& s) {
|
|
s.ext(*this, BaseClass<AbstractBase>{});
|
|
s.value1b(y);
|
|
}
|
|
};
|
|
|
|
TEST(SerializeExtensionInheritance, CanSerializeAbstractClass) {
|
|
ImplementedBase data{};
|
|
data.x = 4;
|
|
data.y = 2;
|
|
data.exec();
|
|
ImplementedBase res{};
|
|
SerContext ctx{};
|
|
ctx.createSerializer().object(data);
|
|
ctx.createDeserializer().object(res);
|
|
EXPECT_THAT(res.x, Eq(data.x));
|
|
EXPECT_THAT(res.y, Eq(data.y));
|
|
} |