mirror of https://github.com/oxen-io/oxen-mq.git
258 lines
11 KiB
C++
258 lines
11 KiB
C++
#include "lokimq/bt_serialize.h"
|
|
#include "common.h"
|
|
#include <map>
|
|
#include <set>
|
|
#include <limits>
|
|
|
|
TEST_CASE("bt basic value serialization", "[bt][serialization]") {
|
|
int x = 42;
|
|
std::string x_ = bt_serialize(x);
|
|
REQUIRE( bt_serialize(x) == "i42e" );
|
|
|
|
int64_t ibig = -8'000'000'000'000'000'000LL;
|
|
uint64_t ubig = 10'000'000'000'000'000'000ULL;
|
|
REQUIRE( bt_serialize(ibig) == "i-8000000000000000000e" );
|
|
REQUIRE( bt_serialize(std::numeric_limits<int64_t>::min()) == "i-9223372036854775808e" );
|
|
REQUIRE( bt_serialize(ubig) == "i10000000000000000000e" );
|
|
REQUIRE( bt_serialize(std::numeric_limits<uint64_t>::max()) == "i18446744073709551615e" );
|
|
|
|
std::unordered_map<std::string, int> m;
|
|
m["hi"] = 123;
|
|
m["omg"] = -7890;
|
|
m["bye"] = 456;
|
|
m["zap"] = 0;
|
|
// bt values are always sorted:
|
|
REQUIRE( bt_serialize(m) == "d3:byei456e2:hii123e3:omgi-7890e3:zapi0ee" );
|
|
|
|
// Dict-like list serializes as a dict (and get sorted, as above)
|
|
std::list<std::pair<std::string, std::string>> d{{
|
|
{"c", "x"},
|
|
{"a", "z"},
|
|
{"b", "y"},
|
|
}};
|
|
REQUIRE( bt_serialize(d) == "d1:a1:z1:b1:y1:c1:xe" );
|
|
|
|
std::vector<std::string> v{{"a", "", "\x00"s, "\x00\x00\x00goo"s}};
|
|
REQUIRE( bt_serialize(v) == "l1:a0:1:\0006:\x00\x00\x00gooe"sv );
|
|
|
|
std::array v2 = {"a"sv, ""sv, "\x00"sv, "\x00\x00\x00goo"sv};
|
|
REQUIRE( bt_serialize(v2) == "l1:a0:1:\0006:\x00\x00\x00gooe"sv );
|
|
}
|
|
|
|
TEST_CASE("bt nested value serialization", "[bt][serialization]") {
|
|
std::unordered_map<std::string, std::list<std::map<std::string, std::set<int>>>> x{{
|
|
{"foo", {{{"a", {1,2,3}}, {"b", {}}}, {{"c", {4,-5}}}}},
|
|
{"bar", {}}
|
|
}};
|
|
REQUIRE( bt_serialize(x) == "d3:barle3:foold1:ali1ei2ei3ee1:bleed1:cli-5ei4eeeee" );
|
|
}
|
|
|
|
TEST_CASE("bt basic value deserialization", "[bt][deserialization]") {
|
|
REQUIRE( bt_deserialize<int>("i42e") == 42 );
|
|
|
|
int64_t ibig = -8'000'000'000'000'000'000LL;
|
|
uint64_t ubig = 10'000'000'000'000'000'000ULL;
|
|
REQUIRE( bt_deserialize<int64_t>("i-8000000000000000000e") == ibig );
|
|
REQUIRE( bt_deserialize<uint64_t>("i10000000000000000000e") == ubig );
|
|
REQUIRE( bt_deserialize<int64_t>("i-9223372036854775808e") == std::numeric_limits<int64_t>::min() );
|
|
REQUIRE( bt_deserialize<uint64_t>("i18446744073709551615e") == std::numeric_limits<uint64_t>::max() );
|
|
REQUIRE( bt_deserialize<uint32_t>("i4294967295e") == std::numeric_limits<uint32_t>::max() );
|
|
|
|
REQUIRE_THROWS( bt_deserialize<int64_t>("i-9223372036854775809e") );
|
|
REQUIRE_THROWS( bt_deserialize<uint64_t>("i-1e") );
|
|
REQUIRE_THROWS( bt_deserialize<uint32_t>("i4294967296e") );
|
|
|
|
std::unordered_map<std::string, int> m;
|
|
m["hi"] = 123;
|
|
m["omg"] = -7890;
|
|
m["bye"] = 456;
|
|
m["zap"] = 0;
|
|
// bt values are always sorted:
|
|
REQUIRE( bt_deserialize<std::unordered_map<std::string, int>>("d3:byei456e2:hii123e3:omgi-7890e3:zapi0ee") == m );
|
|
|
|
// Dict-like list can be used for deserialization
|
|
std::list<std::pair<std::string, std::string>> d{{
|
|
{"a", "z"},
|
|
{"b", "y"},
|
|
{"c", "x"},
|
|
}};
|
|
REQUIRE( bt_deserialize<std::list<std::pair<std::string, std::string>>>("d1:a1:z1:b1:y1:c1:xe") == d );
|
|
|
|
std::vector<std::string> v{{"a", "", "\x00"s, "\x00\x00\x00goo"s}};
|
|
REQUIRE( bt_deserialize<std::vector<std::string>>("l1:a0:1:\0006:\x00\x00\x00gooe"sv) == v );
|
|
|
|
std::vector v2 = {"a"sv, ""sv, "\x00"sv, "\x00\x00\x00goo"sv};
|
|
REQUIRE( bt_deserialize<decltype(v2)>("l1:a0:1:\0006:\x00\x00\x00gooe"sv) == v2 );
|
|
}
|
|
|
|
TEST_CASE("bt_value serialization", "[bt][serialization][bt_value]") {
|
|
bt_value dna{42};
|
|
std::string x_ = bt_serialize(dna);
|
|
REQUIRE( bt_serialize(dna) == "i42e" );
|
|
|
|
bt_value foo{"foo"};
|
|
REQUIRE( bt_serialize(foo) == "3:foo" );
|
|
|
|
bt_value ibig{-8'000'000'000'000'000'000LL};
|
|
bt_value ubig{10'000'000'000'000'000'000ULL};
|
|
int16_t ismall = -123;
|
|
uint16_t usmall = 123;
|
|
bt_dict nums{
|
|
{"a", 0},
|
|
{"b", -8'000'000'000'000'000'000LL},
|
|
{"c", 10'000'000'000'000'000'000ULL},
|
|
{"d", ismall},
|
|
{"e", usmall},
|
|
};
|
|
|
|
REQUIRE( bt_serialize(ibig) == "i-8000000000000000000e" );
|
|
REQUIRE( bt_serialize(ubig) == "i10000000000000000000e" );
|
|
REQUIRE( bt_serialize(nums) == "d1:ai0e1:bi-8000000000000000000e1:ci10000000000000000000e1:di-123e1:ei123ee" );
|
|
|
|
// Same as nested test, above, but with bt_* types
|
|
bt_dict x{{
|
|
{"foo", bt_list{{bt_dict{{ {"a", bt_list{{1,2,3}}}, {"b", bt_list{}}}}, bt_dict{{{"c", bt_list{{-5, 4}}}}}}}},
|
|
{"bar", bt_list{}}
|
|
}};
|
|
REQUIRE( bt_serialize(x) == "d3:barle3:foold1:ali1ei2ei3ee1:bleed1:cli-5ei4eeeee" );
|
|
std::vector<std::string> v{{"a", "", "\x00"s, "\x00\x00\x00goo"s}};
|
|
REQUIRE( bt_serialize(v) == "l1:a0:1:\0006:\x00\x00\x00gooe"sv );
|
|
|
|
std::array v2 = {"a"sv, ""sv, "\x00"sv, "\x00\x00\x00goo"sv};
|
|
REQUIRE( bt_serialize(v2) == "l1:a0:1:\0006:\x00\x00\x00gooe"sv );
|
|
}
|
|
|
|
TEST_CASE("bt_value deserialization", "[bt][deserialization][bt_value]") {
|
|
auto dna1 = bt_deserialize<bt_value>("i42e");
|
|
auto dna2 = bt_deserialize<bt_value>("i-42e");
|
|
REQUIRE( var::get<uint64_t>(dna1) == 42 );
|
|
REQUIRE( var::get<int64_t>(dna2) == -42 );
|
|
REQUIRE_THROWS( var::get<int64_t>(dna1) );
|
|
REQUIRE_THROWS( var::get<uint64_t>(dna2) );
|
|
REQUIRE( lokimq::get_int<int>(dna1) == 42 );
|
|
REQUIRE( lokimq::get_int<int>(dna2) == -42 );
|
|
REQUIRE( lokimq::get_int<unsigned>(dna1) == 42 );
|
|
REQUIRE_THROWS( lokimq::get_int<unsigned>(dna2) );
|
|
|
|
bt_value x = bt_deserialize<bt_value>("d3:barle3:foold1:ali1ei2ei3ee1:bleed1:cli-5ei4eeeee");
|
|
REQUIRE( std::holds_alternative<bt_dict>(x) );
|
|
bt_dict& a = var::get<bt_dict>(x);
|
|
REQUIRE( a.count("bar") );
|
|
REQUIRE( a.count("foo") );
|
|
REQUIRE( a.size() == 2 );
|
|
bt_list& foo = var::get<bt_list>(a["foo"]);
|
|
REQUIRE( foo.size() == 2 );
|
|
bt_dict& foo1 = var::get<bt_dict>(foo.front());
|
|
bt_dict& foo2 = var::get<bt_dict>(foo.back());
|
|
REQUIRE( foo1.size() == 2 );
|
|
REQUIRE( foo2.size() == 1 );
|
|
bt_list& foo1a = var::get<bt_list>(foo1.at("a"));
|
|
bt_list& foo1b = var::get<bt_list>(foo1.at("b"));
|
|
bt_list& foo2c = var::get<bt_list>(foo2.at("c"));
|
|
std::list<int> foo1a_vals, foo1b_vals, foo2c_vals;
|
|
for (auto& v : foo1a) foo1a_vals.push_back(lokimq::get_int<int>(v));
|
|
for (auto& v : foo1b) foo1b_vals.push_back(lokimq::get_int<int>(v));
|
|
for (auto& v : foo2c) foo2c_vals.push_back(lokimq::get_int<int>(v));
|
|
REQUIRE( foo1a_vals == std::list{{1,2,3}} );
|
|
REQUIRE( foo1b_vals == std::list<int>{} );
|
|
REQUIRE( foo2c_vals == std::list{{-5, 4}} );
|
|
|
|
REQUIRE( var::get<bt_list>(a.at("bar")).empty() );
|
|
}
|
|
|
|
TEST_CASE("bt tuple serialization", "[bt][tuple][serialization]") {
|
|
// Deserializing directly into a tuple:
|
|
std::tuple<int, std::string, std::vector<int>> x{42, "hi", {{1,2,3,4,5}}};
|
|
REQUIRE( bt_serialize(x) == "li42e2:hili1ei2ei3ei4ei5eee" );
|
|
|
|
using Y = std::tuple<std::string, std::string, std::unordered_map<std::string, int>>;
|
|
REQUIRE( bt_deserialize<Y>("l5:hello3:omgd1:ai1e1:bi2eee")
|
|
== Y{"hello", "omg", {{"a",1}, {"b",2}}} );
|
|
|
|
using Z = std::tuple<std::tuple<int, std::string, std::string>, std::pair<int, int>>;
|
|
Z z{{3, "abc", "def"}, {4, 5}};
|
|
REQUIRE( bt_serialize(z) == "lli3e3:abc3:defeli4ei5eee" );
|
|
REQUIRE( bt_deserialize<Z>("lli6e3:ghi3:jkleli7ei8eee") == Z{{6, "ghi", "jkl"}, {7, 8}} );
|
|
|
|
using W = std::pair<std::string, std::pair<int, unsigned>>;
|
|
REQUIRE( bt_serialize(W{"zzzzzzzzzz", {42, 42}}) == "l10:zzzzzzzzzzli42ei42eee" );
|
|
|
|
REQUIRE_THROWS( bt_deserialize<std::tuple<int>>("li1e") ); // missing closing e
|
|
REQUIRE_THROWS( bt_deserialize<std::pair<int, int>>("li1ei-4e") ); // missing closing e
|
|
REQUIRE_THROWS( bt_deserialize<std::tuple<int>>("li1ei2ee") ); // too many elements
|
|
REQUIRE_THROWS( bt_deserialize<std::pair<int, int>>("li1ei-2e0:e") ); // too many elements
|
|
REQUIRE_THROWS( bt_deserialize<std::tuple<int, int>>("li1ee") ); // too few elements
|
|
REQUIRE_THROWS( bt_deserialize<std::pair<int, int>>("li1ee") ); // too few elements
|
|
REQUIRE_THROWS( bt_deserialize<std::tuple<std::string>>("li1ee") ); // wrong element type
|
|
REQUIRE_THROWS( bt_deserialize<std::pair<int, std::string>>("li1ei8ee") ); // wrong element type
|
|
REQUIRE_THROWS( bt_deserialize<std::pair<int, std::string>>("l1:x1:xe") ); // wrong element type
|
|
|
|
// Converting from a generic bt_value/bt_list:
|
|
bt_value a = bt_get("l5:hello3:omgi12345ee");
|
|
using V1 = std::tuple<std::string, std::string_view, uint16_t>;
|
|
REQUIRE( get_tuple<V1>(a) == V1{"hello", "omg"sv, 12345} );
|
|
|
|
bt_value b = bt_get("l5:hellod1:ai1e1:bi2eee");
|
|
using V2 = std::pair<std::string_view, bt_dict>;
|
|
REQUIRE( get_tuple<V2>(b) == V2{"hello", {{"a",1U}, {"b",2U}}} );
|
|
|
|
bt_value c = bt_get("l5:helloi-4ed1:ai-1e1:bi-2eee");
|
|
using V3 = std::tuple<std::string, int, bt_dict>;
|
|
REQUIRE( get_tuple<V3>(c) == V3{"hello", -4, {{"a",-1}, {"b",-2}}} );
|
|
|
|
REQUIRE_THROWS( get_tuple<V1>(bt_get("l5:hello3:omge")) ); // too few
|
|
REQUIRE_THROWS( get_tuple<V1>(bt_get("l5:hello3:omgi1ei1ee")) ); // too many
|
|
REQUIRE_THROWS( get_tuple<V1>(bt_get("l5:helloi1ei1ee")) ); // wrong type
|
|
|
|
// Construct a bt_value from tuples:
|
|
bt_value l{std::make_tuple(3, 4, "hi"sv)};
|
|
REQUIRE( bt_serialize(l) == "li3ei4e2:hie" );
|
|
bt_list m{{1, 2, std::make_tuple(3, 4, "hi"sv), std::make_pair("foo"s, "bar"sv), -4}};
|
|
REQUIRE( bt_serialize(m) == "li1ei2eli3ei4e2:hiel3:foo3:barei-4ee" );
|
|
|
|
// Consumer deserialization:
|
|
bt_list_consumer lc{"li1ei2eli3ei4e2:hiel3:foo3:barei-4ee"};
|
|
REQUIRE( lc.consume_integer<int>() == 1 );
|
|
REQUIRE( lc.consume_integer<int>() == 2 );
|
|
REQUIRE( lc.consume_list<std::tuple<int, int, std::string>>() == std::make_tuple(3, 4, "hi"s) );
|
|
REQUIRE( lc.consume_list<std::pair<std::string_view, std::string_view>>() == std::make_pair("foo"sv, "bar"sv) );
|
|
REQUIRE( lc.consume_integer<int>() == -4 );
|
|
|
|
bt_dict_consumer dc{"d1:Ai0e1:ali1e3:omge1:bli1ei2ei3eee"};
|
|
REQUIRE( dc.key() == "A" );
|
|
REQUIRE( dc.skip_until("a") );
|
|
REQUIRE( dc.next_list<std::pair<int8_t, std::string_view>>() ==
|
|
std::make_pair("a"sv, std::make_pair(int8_t{1}, "omg"sv)) );
|
|
REQUIRE( dc.next_list<std::tuple<int, int, int>>() ==
|
|
std::make_pair("b"sv, std::make_tuple(1, 2, 3)) );
|
|
}
|
|
|
|
#if 0
|
|
{
|
|
std::cout << "zomg consumption\n";
|
|
bt_dict_consumer dc{zomg_};
|
|
for (int i = 0; i < 5; i++)
|
|
if (!dc.skip_until("b"))
|
|
throw std::runtime_error("Couldn't find b, but I know it's there!");
|
|
|
|
auto dc1 = dc;
|
|
if (dc.skip_until("z")) {
|
|
auto v = dc.consume_integer<int>();
|
|
std::cout << " - " << v.first << ": " << v.second << "\n";
|
|
} else {
|
|
std::cout << " - no z (bad!)\n";
|
|
}
|
|
|
|
std::cout << "zomg (second pass)\n";
|
|
for (auto &p : dc1.consume_dict().second) {
|
|
std::cout << " - " << p.first << " = (whatever)\n";
|
|
}
|
|
while (dc1) {
|
|
auto v = dc1.consume_integer<int>();
|
|
std::cout << " - " << v.first << ": " << v.second << "\n";
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|