tqcq/ulib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
c3b5a29da2
ulib/3party/rpc_core/test/test_serialize.cpp
tqcq c3b5a29da2
All checks were successful
rpcrypto-build / build (Debug, hisiv510.toolchain.cmake) (push) Successful in 1m6s
Details
rpcrypto-build / build (Debug, himix200.toolchain.cmake) (push) Successful in 1m9s
Details
rpcrypto-build / build (Release, himix200.toolchain.cmake) (push) Successful in 1m17s
Details
rpcrypto-build / build (Release, hisiv510.toolchain.cmake) (push) Successful in 1m22s
Details
linux-hisiv500-gcc / linux-gcc-hisiv500 (push) Successful in 1m39s
Details
linux-mips64-gcc / linux-gcc-mips64el (push) Successful in 1m48s
Details
linux-x64-gcc / linux-gcc (push) Successful in 2m3s
Details
feat add rpc_core
2024-01-21 16:05:01 +08:00

587 lines
15 KiB
C++
Raw Blame History

#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
Reference in New Issue View Git Blame Copy Permalink