binaryreflector.cpp

Go to the documentation of this file.

#include "../binary/reflector-chronoutilities.h"
#include "../binary/reflector.h"
#include "../binary/serializable.h"
 
#include <c++utilities/conversion/stringbuilder.h>
#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/io/misc.h>
#include <c++utilities/tests/testutils.h>
 
using CppUtilities::operator<<; // must be visible prior to the call site
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
 
#include <cstdint>
#include <iostream>
#include <limits>
#include <map>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
 
using namespace std;
using namespace CPPUNIT_NS;
using namespace CppUtilities;
using namespace CppUtilities::Literals;
using namespace ReflectiveRapidJSON;
 
 
// define some enums and structs for testing serialization
enum SomeEnumBinary {
    SomeEnumItem1,
    SomeEnumItem2,
    SomeEnumItem3,
};
 
enum class SomeEnumClassBinary : std::uint16_t {
    Item1,
    Item2,
    Item3,
};
 
struct TestObjectBinary : public BinarySerializable<TestObjectBinary> {
    int number;
    double number2;
    vector<int> numbers;
    string text;
    bool boolean;
    map<string, int> someMap;
    unordered_map<string, bool> someHash;
    set<string> someSet;
    multiset<string> someMultiset;
    unordered_set<string> someUnorderedSet;
    unordered_multiset<string> someUnorderedMultiset;
    SomeEnumBinary someEnum;
    SomeEnumClassBinary someEnumClass;
    TimeSpan timeSpan;
    DateTime dateTime;
};
 
struct NestingArrayBinary : public BinarySerializable<NestingArrayBinary> {
    string name;
    vector<TestObjectBinary> testObjects;
};
 
struct ObjectWithVariantsBinary : public BinarySerializable<ObjectWithVariantsBinary> {
    variant<int, string, monostate> someVariant;
    variant<string, float> anotherVariant;
    variant<string, int> yetAnotherVariant;
};
 
// pretend serialization code for structs has been generated
namespace ReflectiveRapidJSON {
namespace BinaryReflector {
 
template <> BinaryVersion readCustomType<TestObjectBinary>(BinaryDeserializer &deserializer, TestObjectBinary &customType, BinaryVersion version)
{
    CPP_UTILITIES_UNUSED(version)
    deserializer.read(customType.number);
    deserializer.read(customType.number2);
    deserializer.read(customType.numbers);
    deserializer.read(customType.text);
    deserializer.read(customType.boolean);
    deserializer.read(customType.someMap);
    deserializer.read(customType.someHash);
    deserializer.read(customType.someSet);
    deserializer.read(customType.someMultiset);
    deserializer.read(customType.someUnorderedSet);
    deserializer.read(customType.someUnorderedMultiset);
    deserializer.read(customType.someEnum);
    deserializer.read(customType.someEnumClass);
    deserializer.read(customType.timeSpan);
    deserializer.read(customType.dateTime);
    return 0;
}
 
template <> void writeCustomType<TestObjectBinary>(BinarySerializer &serializer, const TestObjectBinary &customType, BinaryVersion version)
{
    CPP_UTILITIES_UNUSED(version)
    serializer.write(customType.number);
    serializer.write(customType.number2);
    serializer.write(customType.numbers);
    serializer.write(customType.text);
    serializer.write(customType.boolean);
    serializer.write(customType.someMap);
    serializer.write(customType.someHash);
    serializer.write(customType.someSet);
    serializer.write(customType.someMultiset);
    serializer.write(customType.someUnorderedSet);
    serializer.write(customType.someUnorderedMultiset);
    serializer.write(customType.someEnum);
    serializer.write(customType.someEnumClass);
    serializer.write(customType.timeSpan);
    serializer.write(customType.dateTime);
}
 
template <> BinaryVersion readCustomType<NestingArrayBinary>(BinaryDeserializer &deserializer, NestingArrayBinary &customType, BinaryVersion version)
{
    CPP_UTILITIES_UNUSED(version)
    deserializer.read(customType.name);
    deserializer.read(customType.testObjects);
    return 0;
}
 
template <> void writeCustomType<NestingArrayBinary>(BinarySerializer &serializer, const NestingArrayBinary &customType, BinaryVersion version)
{
    CPP_UTILITIES_UNUSED(version)
    serializer.write(customType.name);
    serializer.write(customType.testObjects);
}
 
template <>
BinaryVersion readCustomType<ObjectWithVariantsBinary>(BinaryDeserializer &deserializer, ObjectWithVariantsBinary &customType, BinaryVersion version)
{
    CPP_UTILITIES_UNUSED(version)
    deserializer.read(customType.someVariant);
    deserializer.read(customType.anotherVariant);
    deserializer.read(customType.yetAnotherVariant);
    return 0;
}
 
template <>
void writeCustomType<ObjectWithVariantsBinary>(BinarySerializer &serializer, const ObjectWithVariantsBinary &customType, BinaryVersion version)
{
    CPP_UTILITIES_UNUSED(version)
    serializer.write(customType.someVariant);
    serializer.write(customType.anotherVariant);
    serializer.write(customType.yetAnotherVariant);
}
 
} // namespace BinaryReflector
 
// namespace BinaryReflector
} // namespace ReflectiveRapidJSON
 
 
class BinaryReflectorTests : public TestFixture {
    CPPUNIT_TEST_SUITE(BinaryReflectorTests);
    CPPUNIT_TEST(testSerializeSimpleStruct);
    CPPUNIT_TEST(testDeserializeSimpleStruct);
    CPPUNIT_TEST(testSerializeNestedStruct);
    CPPUNIT_TEST(testDeserializeNestedStruct);
    CPPUNIT_TEST(testSmallSharedPointer);
    CPPUNIT_TEST(testBigSharedPointer);
    CPPUNIT_TEST(testVariant);
    CPPUNIT_TEST(testOptional);
    CPPUNIT_TEST_SUITE_END();
 
public:
    BinaryReflectorTests();
 
    void setUp() override;
    void tearDown() override;
 
    void testSerializeSimpleStruct();
    void testDeserializeSimpleStruct();
    void testSerializeNestedStruct();
    void testDeserializeNestedStruct();
    void assertTestObject(const TestObjectBinary &deserialized);
    void testSharedPointer(std::uintptr_t fakePointer);
    void testSmallSharedPointer();
    void testBigSharedPointer();
    void testVariant();
    void testOptional();
 
private:
    vector<unsigned char> m_buffer;
    TestObjectBinary m_testObj;
    NestingArrayBinary m_nestedTestObj;
    vector<unsigned char> m_expectedTestObj;
    vector<unsigned char> m_expectedNestedTestObj;
};
 
CPPUNIT_TEST_SUITE_REGISTRATION(BinaryReflectorTests);
 
// clang-format off
BinaryReflectorTests::BinaryReflectorTests()
    : m_buffer()
    , m_testObj()
    , m_nestedTestObj()
    , m_expectedTestObj({
               0x00, 0x00, 0x00, 0x05,
               0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
               0x85,
                 0x00, 0x00, 0x00, 0x01,
                 0x00, 0x00, 0x00, 0x02,
                 0x00, 0x00, 0x00, 0x03,
                 0x00, 0x00, 0x00, 0x04,
                 0x00, 0x00, 0x00, 0x05,
               0x89,
                 0x73, 0x6F, 0x6D, 0x65, 0x20, 0x74, 0x65, 0x78, 0x74,
               0x01,
               0x82,
                 0x83, 0x62, 0x61, 0x72, 0x00, 0x00, 0x00, 0x13,
                 0x83, 0x66, 0x6f, 0x6f, 0x00, 0x00, 0x00, 0x11,
               0x80,
               0x83,
                 0x81, 0x31,
                 0x81, 0x32,
                 0x81, 0x33,
               0x84,
                 0x81, 0x31,
                 0x81, 0x32,
                 0x81, 0x32,
                 0x81, 0x33,
               0x80,
               0x80,
               0x00, 0x00, 0x00, 0x01,
               0x00, 0x02,
               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAB, 0xCD,
               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF, 0xAB,
           })
    , m_expectedNestedTestObj({
               0x93, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67,
               0x82,
                              })
{
}
// clang-format on
 
void BinaryReflectorTests::setUp()
{
    m_testObj.number = 5;
    m_testObj.number2 = 2.5;
    m_testObj.numbers = { 1, 2, 3, 4, 5 };
    m_testObj.text = "some text";
    m_testObj.boolean = true;
    m_testObj.someMap = {
        { "foo", 17 },
        { "bar", 19 },
    };
    m_testObj.someSet = { "1", "2", "3", "2" };
    m_testObj.someMultiset = { "1", "2", "3", "2" };
    m_testObj.someEnum = SomeEnumItem2;
    m_testObj.someEnumClass = SomeEnumClassBinary::Item3;
    m_testObj.timeSpan = TimeSpan(0xABCD);
    m_testObj.dateTime = DateTime(0xEFAB);
    m_nestedTestObj.name = "struct with nesting";
    m_expectedNestedTestObj.reserve(m_expectedNestedTestObj.size() + 2 * m_expectedTestObj.size());
    m_expectedNestedTestObj.insert(m_expectedNestedTestObj.end(), m_expectedTestObj.cbegin(), m_expectedTestObj.cend());
    m_expectedNestedTestObj.insert(m_expectedNestedTestObj.end(), m_expectedTestObj.cbegin(), m_expectedTestObj.cend());
    m_nestedTestObj.testObjects.insert(m_nestedTestObj.testObjects.end(), 2, m_testObj);
}
 
void BinaryReflectorTests::tearDown()
{
}
 
static void setBuffer(std::stringstream &stream, unsigned char *buffer, std::size_t bufferSize)
{
#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION)
    stream.rdbuf()->pubsetbuf(reinterpret_cast<char *>(buffer), static_cast<std::streamsize>(bufferSize));
#else
    CPP_UTILITIES_UNUSED(stream)
    CPP_UTILITIES_UNUSED(buffer)
    CPP_UTILITIES_UNUSED(bufferSize)
#endif
}
 
static void readBuffer(std::stringstream &stream, unsigned char *buffer, std::size_t bufferSize)
{
#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION)
    CPP_UTILITIES_UNUSED(stream)
    CPP_UTILITIES_UNUSED(buffer)
    CPP_UTILITIES_UNUSED(bufferSize)
#else
    stream.read(reinterpret_cast<char *>(buffer), static_cast<std::streamsize>(bufferSize));
#endif
}
static void writeBuffer(std::stringstream &stream, unsigned char *buffer, std::size_t bufferSize)
{
#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION)
    stream.rdbuf()->pubsetbuf(reinterpret_cast<char *>(buffer), static_cast<std::streamsize>(bufferSize));
#else
    stream.write(reinterpret_cast<const char *>(buffer), static_cast<std::streamsize>(bufferSize));
#endif
}
 
void BinaryReflectorTests::testSerializeSimpleStruct()
{
    stringstream stream(ios_base::out | ios_base::binary);
    stream.exceptions(ios_base::failbit | ios_base::badbit);
    m_buffer.resize(m_expectedTestObj.size());
    setBuffer(stream, m_buffer.data(), m_buffer.size());
    m_testObj.toBinary(stream);
    readBuffer(stream, m_buffer.data(), m_buffer.size());
 
    CPPUNIT_ASSERT_EQUAL(m_expectedTestObj, m_buffer);
}
 
void BinaryReflectorTests::testDeserializeSimpleStruct()
{
    stringstream stream(ios_base::in | ios_base::binary);
    stream.exceptions(ios_base::failbit | ios_base::badbit);
    writeBuffer(stream, m_expectedTestObj.data(), m_expectedTestObj.size());
    const auto deserialized(TestObjectBinary::fromBinary(stream));
    assertTestObject(deserialized);
}
 
void BinaryReflectorTests::testSerializeNestedStruct()
{
    stringstream stream(ios_base::out | ios_base::binary);
    stream.exceptions(ios_base::failbit | ios_base::badbit);
    m_buffer.resize(m_expectedNestedTestObj.size());
    setBuffer(stream, m_buffer.data(), m_buffer.size());
    m_nestedTestObj.toBinary(stream);
    readBuffer(stream, m_buffer.data(), m_buffer.size());
 
    CPPUNIT_ASSERT_EQUAL(m_expectedNestedTestObj, m_buffer);
}
 
void BinaryReflectorTests::testDeserializeNestedStruct()
{
    stringstream stream(ios_base::in | ios_base::binary);
    stream.exceptions(ios_base::failbit | ios_base::badbit);
    writeBuffer(stream, m_expectedNestedTestObj.data(), m_expectedNestedTestObj.size());
 
    const auto deserialized(NestingArrayBinary::fromBinary(stream));
    CPPUNIT_ASSERT_EQUAL(m_nestedTestObj.name, deserialized.name);
    for (const auto &testObj : deserialized.testObjects) {
        assertTestObject(testObj);
    }
}
 
void BinaryReflectorTests::assertTestObject(const TestObjectBinary &deserialized)
{
    CPPUNIT_ASSERT_EQUAL(m_testObj.number, deserialized.number);
    CPPUNIT_ASSERT_EQUAL(m_testObj.number2, deserialized.number2);
    CPPUNIT_ASSERT_EQUAL(m_testObj.numbers, deserialized.numbers);
    CPPUNIT_ASSERT_EQUAL(m_testObj.text, deserialized.text);
    CPPUNIT_ASSERT_EQUAL(m_testObj.boolean, deserialized.boolean);
    CPPUNIT_ASSERT_EQUAL(m_testObj.someMap, deserialized.someMap);
    CPPUNIT_ASSERT_EQUAL(m_testObj.someHash, deserialized.someHash);
    CPPUNIT_ASSERT_EQUAL(m_testObj.someSet, deserialized.someSet);
    CPPUNIT_ASSERT_EQUAL(m_testObj.someMultiset, deserialized.someMultiset);
    CPPUNIT_ASSERT_EQUAL(m_testObj.someUnorderedSet, deserialized.someUnorderedSet);
    CPPUNIT_ASSERT_EQUAL(m_testObj.someUnorderedMultiset, deserialized.someUnorderedMultiset);
}
 
void BinaryReflectorTests::testSharedPointer(uintptr_t fakePointer)
{
    // create a shared pointer for the fake pointer ensuring that it is not actually deleted
    shared_ptr<int> sharedPointer(reinterpret_cast<int *>(fakePointer), [](int *) {});
 
    // setup stream
    stringstream stream(ios_base::in | ios_base::out | ios_base::binary);
    stream.exceptions(ios_base::failbit | ios_base::badbit);
 
    // serialize the shared pointer assuming its contents have been written before (to prevent actually dereferencing it)
    BinaryReflector::BinarySerializer serializer(&stream);
    serializer.m_pointer[fakePointer] = true;
    serializer.write(sharedPointer);
 
    // deserialize the shared pointer assuming it has already been read and the type does not match
    BinaryReflector::BinaryDeserializer deserializer(&stream);
    shared_ptr<int> readPtr;
    deserializer.m_pointer[fakePointer] = "foo";
    CPPUNIT_ASSERT_THROW(deserializer.read(readPtr), CppUtilities::ConversionException);
    CPPUNIT_ASSERT(readPtr == nullptr);
 
    // deserialize the shared pointer assuming it has already been read and the type matches
    stream.seekg(0);
    deserializer.m_pointer[fakePointer] = make_shared<int>(42);
    deserializer.read(readPtr);
    CPPUNIT_ASSERT(readPtr != nullptr);
    CPPUNIT_ASSERT_EQUAL(42, *readPtr);
}
 
void BinaryReflectorTests::testSmallSharedPointer()
{
    testSharedPointer(std::numeric_limits<std::uintptr_t>::min() + 1);
}
 
void BinaryReflectorTests::testBigSharedPointer()
{
    testSharedPointer(std::numeric_limits<std::uintptr_t>::max());
}
 
void BinaryReflectorTests::testVariant()
{
    // create test object
    ObjectWithVariantsBinary variants;
    variants.someVariant = std::monostate{};
    variants.anotherVariant = "foo";
    variants.yetAnotherVariant = 42;
 
    // serialize test object
    stringstream stream(ios_base::in | ios_base::out | ios_base::binary);
    stream.exceptions(ios_base::failbit | ios_base::badbit);
    variants.toBinary(stream);
 
    // deserialize the object again
    const auto deserializedVariants = ObjectWithVariantsBinary::fromBinary(stream);
 
    CPPUNIT_ASSERT_EQUAL(2_st, deserializedVariants.someVariant.index());
    CPPUNIT_ASSERT_EQUAL(0_st, deserializedVariants.anotherVariant.index());
    CPPUNIT_ASSERT_EQUAL(1_st, deserializedVariants.yetAnotherVariant.index());
    CPPUNIT_ASSERT_EQUAL("foo"s, get<0>(deserializedVariants.anotherVariant));
    CPPUNIT_ASSERT_EQUAL(42, get<1>(deserializedVariants.yetAnotherVariant));
}
 
void BinaryReflectorTests::testOptional()
{
    // create test objects
    const auto str = std::make_optional<std::string>("foo");
    const auto nullStr = std::optional<std::string>();
 
    // serialize test object
    auto stream = std::stringstream(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
    stream.exceptions(std::ios_base::failbit | std::ios_base::badbit);
    auto ser = BinaryReflector::BinarySerializer(&stream);
    ser.write(str);
    ser.write(nullStr);
 
    // deserialize the object again
    auto deser = BinaryReflector::BinaryDeserializer(&stream);
    auto deserStr = std::optional<std::string>();
    auto deserNullStr = std::optional<std::string>();
    deser.read(deserStr);
    deser.read(deserNullStr);
 
    CPPUNIT_ASSERT(deserStr.has_value());
    CPPUNIT_ASSERT_EQUAL("foo"s, deserStr.value());
    CPPUNIT_ASSERT(!nullStr.has_value());
}