ulib/3party/rpc_core/test/test_serialize.cpp

#include <cinttypes>

#include "assert_def.h"
#include "rpc_core.hpp"
#include "serialize/CustomType.h"

namespace rpc_core_test {

static size_t last_serialize_size = 0;

template <typename T, typename R>
void serialize_test(const T& a, R& b) {
  std::string data = rpc_core::serialize(a);
  last_serialize_size = data.size();
  RPC_CORE_LOGI("  size: %zu", last_serialize_size);
  bool ret = rpc_core::deserialize(data, b);
  ASSERT(ret);
}

template <typename T>
void raw_type_test() {
  T a = 123;
  T b;
  serialize_test(a, b);
  auto ok = (0 == memcmp(&a, &b, sizeof(T)));  // NOLINT
  ASSERT(ok);
}

#define RAW_TYPE_TEST(t)       \
  RPC_CORE_LOGI("  <" #t ">"); \
  raw_type_test<t>();

#define ASSERT_SERIALIZE_SIZE(x) ASSERT(last_serialize_size == x)

static bool is_little_endian() {
  int x = 1;
  return *(char*)&x != 0;
}

static void test_auto_size() {
  using namespace rpc_core::detail;
  auto test_auto_size = [](size_t value, int except_size) {
    RPC_CORE_LOGI("value: 0x%" PRIxMAX "(%" PRIiMAX ") except: %d", value, value, except_size);
    auto_size a(value);
    std::string payload = a.serialize();
    ASSERT(payload.size() == (size_t)except_size);
    auto_size b;
    int cost = b.deserialize(payload.data());
    ASSERT(cost = except_size);
    ASSERT(value == b.value);
  };
  test_auto_size(0x00, 1);
  test_auto_size(0x01, 2);
  test_auto_size(0xff, 2);
  test_auto_size(0xfff, 3);
  test_auto_size(0xffff, 3);
  test_auto_size(0xfffff, 4);
  test_auto_size(0xffffff, 4);
  test_auto_size(0xfffffff, 5);
  test_auto_size(0xffffffff, 5);

  auto test_auto_int = [](intmax_t value, int except_size) {
    RPC_CORE_LOGI("value: 0x%" PRIxMAX "(%" PRIiMAX ") except: %d", value, value, except_size);
    auto_intmax a(value);
    std::string payload = a.serialize();
    ASSERT(payload.size() == (size_t)except_size);
    auto_intmax b;
    int cost = b.deserialize(payload.data());
    ASSERT(cost = except_size);
    ASSERT(value == b.value);
  };
  test_auto_int(0x00, 1);
  test_auto_int(0xff, 2);
  test_auto_int(-0xff, 2);
  test_auto_int(0xffff, 3);
  test_auto_int(-0xffff, 3);
  test_auto_int(0xffffff, 4);
  test_auto_int(-0xffffff, 4);
  test_auto_int(intmax_t(0xffffffff), 5);
  test_auto_int(-(intmax_t(0xffffffff)), 5);

  auto test_auto_uint = [](uintmax_t value, int except_size) {
    RPC_CORE_LOGI("value: 0x%" PRIxMAX "(%" PRIiMAX ") except: %d", value, value, except_size);
    auto_uintmax a(value);
    std::string payload = a.serialize();
    ASSERT(payload.size() == (size_t)except_size);
    auto_uintmax b;
    int cost = b.deserialize(payload.data());
    ASSERT(cost = except_size);
    ASSERT(value == b.value);
  };
  test_auto_uint(0x00, 1);
  test_auto_uint(0xff, 2);
  test_auto_uint(0xffff, 3);
  test_auto_uint(0xffffff, 4);
  test_auto_uint(uintmax_t(0xffffffff), 5);
}

void test_serialize() {
  /// only support little endian
  ASSERT(is_little_endian());

  /// auto_size
  test_auto_size();

  /// raw type
  {
    int32_t a = -1;
    int32_t b = 0;

    std::string data = rpc_core::serialize(a);
    bool ret = rpc_core::deserialize(data, b);
    ASSERT(ret);

    RPC_CORE_LOGI("raw type test...");
    RAW_TYPE_TEST(char);
    ASSERT_SERIALIZE_SIZE(1);
    RAW_TYPE_TEST(int8_t);
    ASSERT_SERIALIZE_SIZE(1);
    RAW_TYPE_TEST(uint8_t);
    ASSERT_SERIALIZE_SIZE(1);
    RAW_TYPE_TEST(int16_t);
    ASSERT_SERIALIZE_SIZE(2);
    RAW_TYPE_TEST(uint16_t);
    ASSERT_SERIALIZE_SIZE(2);
    RAW_TYPE_TEST(int32_t);
    ASSERT_SERIALIZE_SIZE(2);
    RAW_TYPE_TEST(uint32_t);
    ASSERT_SERIALIZE_SIZE(2);
    RAW_TYPE_TEST(int64_t);
    ASSERT_SERIALIZE_SIZE(2);
    RAW_TYPE_TEST(uint64_t);
    ASSERT_SERIALIZE_SIZE(2);
    RAW_TYPE_TEST(float);
    ASSERT_SERIALIZE_SIZE(4);
    RAW_TYPE_TEST(double);
    ASSERT_SERIALIZE_SIZE(8);
    RAW_TYPE_TEST(long double);
    ASSERT_SERIALIZE_SIZE(16);
  }

  /// enum
  {
    enum class Enum {
      k_0,
      k_1,
    };
    RPC_CORE_LOGI("enum...");
    Enum a = Enum::k_1;
    Enum b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2);
  }

  /// std::array
  {
    RPC_CORE_LOGI("std::array...");
    std::array<uint32_t, 3> a{1, 2, 3};
    std::array<uint32_t, 3> b{};
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }

  /// std::string
  {
    RPC_CORE_LOGI("std::string...");
    std::string a = "test";
    std::string b;
    serialize_test(a, b);
    ASSERT(b == a);
    ASSERT_SERIALIZE_SIZE(a.size());
  }

  /// std::wstring
  {
    RPC_CORE_LOGI("std::wstring...");
    std::wstring a = L"中文";
    std::wstring b;
    serialize_test(a, b);
    ASSERT(b == a);
    ASSERT_SERIALIZE_SIZE(a.size() * sizeof(wchar_t));
  }

  /// std::tuple
  {
    RPC_CORE_LOGI("std::tuple...");
    bool msg1 = true;
    uint32_t msg2 = 12;
    std::string msg3 = "test";
    std::tuple<bool, uint32_t, std::string> a(msg1, msg2, msg3);
    std::tuple<bool, uint32_t, std::string> b;
    serialize_test(a, b);
    ASSERT(std::get<0>(b) == msg1);
    ASSERT(std::get<1>(b) == msg2);
    ASSERT(std::get<2>(b) == msg3);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE((1) + (2) + (2 /*size*/ + msg3.size()));
  }

  /// std::pair
  {
    RPC_CORE_LOGI("std::pair...");
    std::pair<std::string, std::string> a{"k:1", "v:1"};
    std::pair<std::string, std::string> b;
    serialize_test(a, b);
    ASSERT(b == a);
    ASSERT_SERIALIZE_SIZE((2 /*size*/ + 3) * 2);
  }

  /// list_like type
  {
    RPC_CORE_LOGI("std::vector...");
    std::vector<uint32_t> a{1, 2, 3};
    std::vector<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }
  {
    RPC_CORE_LOGI("std::list...");
    std::list<uint32_t> a{1, 2, 3};
    std::list<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }
  {
    RPC_CORE_LOGI("std::deque...");
    std::deque<uint32_t> a{1, 2, 3};
    std::deque<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }

  /// std container adaptors
  {
    RPC_CORE_LOGI("std::stack...");
    std::stack<uint32_t> a;
    a.push(1);
    a.push(2);
    a.push(3);
    std::stack<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }
  {
    RPC_CORE_LOGI("std::queue...");
    std::queue<uint32_t> a;
    a.push(1);
    a.push(2);
    a.push(3);
    std::queue<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }
  {
    RPC_CORE_LOGI("std::priority_queue...");
    std::priority_queue<uint32_t> a;
    a.push(1);
    a.push(2);
    a.push(3);
    std::priority_queue<uint32_t> b;
    serialize_test(a, b);
    for (uint32_t i = 0; i < a.size(); ++i) {
      ASSERT(a.top() == b.top());
      a.pop();
      b.pop();
    }
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }

  /// std::bitset
  {
    RPC_CORE_LOGI("std::bitset...");
    std::bitset<8> a;
    a.set();
    std::bitset<8> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(8 /*11111111*/);
  }

  /// std::forward_list
  {
    RPC_CORE_LOGI("std::forward_list...");
    std::forward_list<uint32_t> a{1, 2, 3};
    std::forward_list<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }

  /// std::set
  {
    RPC_CORE_LOGI("std::set...");
    std::set<uint32_t> a{1, 2, 3};
    std::set<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }

  /// std::multiset
  {
    RPC_CORE_LOGI("std::multiset...");
    std::multiset<uint32_t> a{1, 2, 3};
    std::multiset<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }

  /// std::unordered_multiset
  {
    RPC_CORE_LOGI("std::unordered_multiset...");
    std::unordered_multiset<uint32_t> a{1, 2, 3};
    std::unordered_multiset<uint32_t> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + 2 * 3);
  }

  /// std::map
  {
    RPC_CORE_LOGI("std::map...");
    std::map<std::string, std::string> a{{"k:1", "v:1"}, {"k:2", "v:2"}, {"k:3", "v:3"}};
    std::map<std::string, std::string> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + (2 /*std::pair*/ + (2 + 3) * 2) * 3);
  }

  /// std::unordered_map
  {
    RPC_CORE_LOGI("std::unordered_map...");
    std::unordered_map<std::string, std::string> a{{"k:1", "v:1"}, {"k:2", "v:2"}, {"k:3", "v:3"}};
    std::unordered_map<std::string, std::string> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + (2 /*std::pair*/ + (2 + 3) * 2) * 3);
  }

  /// std::multimap
  {
    RPC_CORE_LOGI("std::multimap...");
    std::multimap<std::string, std::string> a{{"k:1", "v:1"}, {"k:2", "v:2"}, {"k:3", "v:3"}};
    std::multimap<std::string, std::string> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + (2 /*std::pair*/ + (2 + 3) * 2) * 3);
  }

  /// std::unordered_multimap
  {
    RPC_CORE_LOGI("std::unordered_multimap...");
    std::unordered_multimap<std::string, std::string> a{{"k:1", "v:1"}, {"k:2", "v:2"}, {"k:3", "v:3"}};
    std::unordered_multimap<std::string, std::string> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2 /*size*/ + (2 /*std::pair*/ + (2 + 3) * 2) * 3);
  }

  /// ptr
  {
    RPC_CORE_LOGI("ptr...");
    int* a = (int*)123;
    int* b = nullptr;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2);  // auto size
  }

  /// binary_wrap
  {
    RPC_CORE_LOGI("binary_wrap...");
    {
      uint8_t array[] = {1, 2, 3};
      size_t data_bytes = sizeof(array);
      rpc_core::binary_wrap a(array, data_bytes);
      rpc_core::binary_wrap b;
      serialize_test(a, b);
      ASSERT(b.size == data_bytes);
      ASSERT(b.data != array);
      ASSERT(0 == memcmp(array, b.data, data_bytes));
      ASSERT_SERIALIZE_SIZE(2 /*size*/ + data_bytes);
    }
    {
      uint8_t array[] = {1, 2, 3};
      struct Test {
        uint8_t* ptr = nullptr;
        rpc_core::binary_wrap bin;
        RPC_CORE_DEFINE_TYPE_INNER(ptr, bin);
      };
      Test a;
      a.ptr = array;
      a.bin = {array, sizeof(array)};
      Test b;
      serialize_test(a, b);
      ASSERT(b.ptr == array);
      ASSERT(b.bin.size == sizeof(array));
      ASSERT(b.bin.data != array);
      ASSERT(0 == memcmp(array, b.bin.data, sizeof(array)));
    }
  }

  /// std::shared_ptr
  {
    RPC_CORE_LOGI("std::shared_ptr...");
    {
      std::shared_ptr<std::string> a = std::make_shared<std::string>("test");
      std::shared_ptr<std::string> b;
      serialize_test(a, b);
      ASSERT(*a == *b);
      ASSERT_SERIALIZE_SIZE(1 /*flag*/ + a->size());
    }
    {
      std::shared_ptr<std::string> a = nullptr;
      std::shared_ptr<std::string> b;
      serialize_test(a, b);
      ASSERT(a == b);
      ASSERT_SERIALIZE_SIZE(1 /*flag*/);
    }
  }

  /// std::unique_ptr
  {
    RPC_CORE_LOGI("std::unique_ptr...");
    {
      std::unique_ptr<std::string> a = std::unique_ptr<std::string>(new std::string("test"));
      std::unique_ptr<std::string> b;
      serialize_test(a, b);
      ASSERT(*a == *b);
      ASSERT_SERIALIZE_SIZE(1 /*flag*/ + a->size());
    }
    {
      std::unique_ptr<std::string> a = nullptr;
      std::unique_ptr<std::string> b;
      serialize_test(a, b);
      ASSERT(a == b);
      ASSERT_SERIALIZE_SIZE(1 /*flag*/);
    }
  }

  /// std::complex
  {
    RPC_CORE_LOGI("std::complex...");
    {
      std::complex<float> a;
      a.real(1.23f);
      a.imag(3.21f);
      std::complex<float> b;
      serialize_test(a, b);
      ASSERT(a == b);
      ASSERT_SERIALIZE_SIZE(4 /*float*/ * 2);
    }
    {
      std::complex<CustomType> a;
      {
        CustomType t;
        t.id = 1;
        t.ids = {1, 2, 3};
        t.name = "test";
        a.real(t);
        a.imag(t);
      }
      std::complex<CustomType> b;
      serialize_test(a, b);
      ASSERT(a == b);
      ASSERT_SERIALIZE_SIZE(40);
    }
  }

  /// std::duration
  {
    RPC_CORE_LOGI("std::duration...");
    std::chrono::seconds a(123);
    std::chrono::seconds b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(2);  // auto size
  }

  /// std::time_point
  {
    RPC_CORE_LOGI("std::time_point...");
    std::chrono::time_point<std::chrono::steady_clock> a = std::chrono::time_point<std::chrono::steady_clock>::max();
    std::chrono::time_point<std::chrono::steady_clock> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(9);
  }

  /// custom class/struct
  {
    RPC_CORE_LOGI("custom type...");
    CustomType a;
    a.id = 1;
    a.ids = {1, 2, 3};
    a.name = "test";
    CustomType b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE((2) + (2 /*ids bytes*/ + 2 /*ids size*/ + 2 * 3) + (2 /*name bytes*/ + 4));
  }

  {
    RPC_CORE_LOGI("custom ptr...");
    CustomTypePtr a;
    a.int_n = nullptr;
    a.int_v = (int32_t*)1;
    a.unique_ptr_n = nullptr;
    a.unique_ptr_v = std::unique_ptr<int32_t>(new int32_t(1));
    a.shared_ptr_n = nullptr;
    a.shared_ptr_v = std::make_shared<int32_t>(1);
    CustomTypePtr b;
    serialize_test(a, b);
    ASSERT(b.int_n == nullptr);
    ASSERT(b.int_v == (int32_t*)1);
    ASSERT(b.unique_ptr_n == nullptr);
    ASSERT(*b.unique_ptr_v == 1);
    ASSERT(b.shared_ptr_n == nullptr);
    ASSERT(*b.shared_ptr_v == 1);
    ASSERT_SERIALIZE_SIZE(23);
  }

  {
    RPC_CORE_LOGI("custom type(different alignas)...");
    CustomType2 a;
    a.id1 = 1;
    a.id2 = 2;
    a.id3 = 3;
    CustomType3 b;
    serialize_test(a, b);
    ASSERT(a.id1 == b.id1);
    ASSERT(a.id2 == b.id2);
    ASSERT(a.id3 == b.id3);
    ASSERT_SERIALIZE_SIZE(4);
  }
  {
    RPC_CORE_LOGI("custom type(nest define)...");
    test::CustomTypeNest a;
    a.c2.id1 = 1;
    a.c2.id2 = 2;
    a.c2.id3 = 3;
    test::CustomTypeNest b;
    serialize_test(a, b);
    ASSERT(a.c2.id1 == b.c2.id1);
    ASSERT(a.c2.id2 == b.c2.id2);
    ASSERT(a.c2.id3 == b.c2.id3);
    ASSERT_SERIALIZE_SIZE(14);
  }
  {
    RPC_CORE_LOGI("custom type(inner)...");
    test::CustomTypeNest2 a;
    a.c2.id1 = 1;
    a.c2.id2 = 2;
    a.c2.id3 = 3;
    test::CustomTypeNest2 b;
    serialize_test(a, b);
    ASSERT(a.c2.id1 == b.c2.id1);
    ASSERT(a.c2.id2 == b.c2.id2);
    ASSERT(a.c2.id3 == b.c2.id3);
    ASSERT_SERIALIZE_SIZE(14);
  }

  /// misc types
  {
    RPC_CORE_LOGI("misc types...");
    CustomType customType;
    customType.id = 1;
    customType.ids = {1, 2, 3};
    customType.name = "test";
    std::tuple<bool, std::vector<std::tuple<uint32_t>>, std::string, CustomType> a{true, {{1}, {2}}, "test", customType};
    std::tuple<bool, std::vector<std::tuple<uint32_t>>, std::string, CustomType> b;
    serialize_test(a, b);
    ASSERT(a == b);
    ASSERT_SERIALIZE_SIZE(39);
  }
}

}  // namespace rpc_core_test