such-gitea/wownero-lws
1
0
Fork 1
mirror of https://codeberg.org/wownero/wownero-lws synced 2026-01-09 23:25:16 -08:00
Code Issues Packages Projects Releases Wiki Activity

Update ::wire:: to be closer to Monero variant (#70)

Browse Source
This commit is contained in:
Lee *!* Clagett
2023-06-07 09:01:46 -04:00
committed by Lee *!* Clagett
parent 3e0555e07d
commit e1bd9541f1
36 changed files with 992 additions and 587 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
tests/unit/rpc/admin.test.cpp
View File

@@ -46,12 +46,13 @@ namespace
expect<epee::byte_slice> call_endpoint(lws::db::storage disk, std::string json)
{
using request_type = typename T::request;
expect<request_type> req = wire::json::from_bytes<request_type>(std::move(json));
if (!req)
return req.error();
request_type req{};
const std::error_code error = wire::json::from_bytes(std::move(json), req);
if (error)
return error;
wire::json_slice_writer out{};
MONERO_CHECK(T{}(out, std::move(disk), std::move(*req)));
return out.take_bytes();
MONERO_CHECK(T{}(out, std::move(disk), std::move(req)));
return epee::byte_slice{out.take_sink()};
}
}
@@ -138,7 +139,7 @@ LWS_CASE("rpc::admin")
{
wire::json_slice_writer out{};
EXPECT(lws::rpc::webhook_list(out, db.clone()));
expect<epee::byte_slice> bytes = out.take_bytes();
expect<epee::byte_slice> bytes = epee::byte_slice{out.take_sink()};
EXPECT(!bytes.has_error());
{

22
tests/unit/wire/json/read.write.test.cpp
View File

@@ -47,16 +47,15 @@ namespace
{
SETUP("Basic values with " + boost::core::demangle(typeid(T).name()) + " integers")
{
const auto result =
wire::json::from_bytes<basic_object<T>>(std::string{basic_json});
EXPECT(result);
EXPECT(result->utf8 == basic_string);
basic_object<T> result{};
EXPECT(!wire::json::from_bytes(std::string{basic_json}, result));
EXPECT(result.utf8 == basic_string);
{
const std::vector<T> expected{0, 127};
EXPECT(result->vec == expected);
EXPECT(result.vec == expected);
}
EXPECT(result->data == lws_test::blob_test1);
EXPECT(result->choice);
EXPECT(result.data == lws_test::blob_test1);
EXPECT(result.choice);
}
}
@@ -66,7 +65,8 @@ namespace
SETUP("Basic values with " + boost::core::demangle(typeid(T).name()) + " integers")
{
const basic_object<T> val{basic_string, std::vector<T>{0, 127}, lws_test::blob_test1, true};
const auto result = wire::json::to_bytes(val);
epee::byte_slice result{};
EXPECT(!wire::json::to_bytes(result, val));
EXPECT(boost::range::equal(result, std::string{basic_json}));
}
}
@@ -91,9 +91,11 @@ LWS_CASE("wire::json_reader")
i64_limit::max() <= std::numeric_limits<std::uintmax_t>::max(),
"expected int64_t::max <= uintmax_t::max"
);
std::uint64_t one = 0;
std::int64_t two = 0;
std::string big_number = std::to_string(std::uintmax_t(i64_limit::max()) + 1);
EXPECT(wire::json::from_bytes<std::uint64_t>(negative_number) == wire::error::schema::larger_integer);
EXPECT(wire::json::from_bytes<std::int64_t>(std::move(big_number)) == wire::error::schema::smaller_integer);
EXPECT(wire::json::from_bytes(negative_number, one) == wire::error::schema::larger_integer);
EXPECT(wire::json::from_bytes(std::move(big_number), two) == wire::error::schema::smaller_integer);
}
LWS_CASE("wire::json_writer")

41
tests/unit/wire/msgpack/read.write.test.cpp
View File

@@ -86,16 +86,17 @@ namespace
{
SETUP("Basic (string keys) with " + boost::core::demangle(typeid(T).name()) + " integers")
{
const auto result =
wire::msgpack::from_bytes<basic_object<T>>(epee::byte_slice{{basic_msgpack}});
EXPECT(result);
EXPECT(result->utf8 == basic_string);
basic_object<T> result{};
const std::error_code error =
wire::msgpack::from_bytes(epee::byte_slice{{basic_msgpack}}, result);
EXPECT(!error);
EXPECT(result.utf8 == basic_string);
{
const std::vector<T> expected{0, 127};
EXPECT(result->vec == expected);
EXPECT(result.vec == expected);
}
EXPECT(result->data == lws_test::blob_test1);
EXPECT(result->choice);
EXPECT(result.data == lws_test::blob_test1);
EXPECT(result.choice);
}
}
@@ -104,16 +105,17 @@ namespace
{
SETUP("Advanced (integer keys) with " + boost::core::demangle(typeid(T).name()) + " integers")
{
const auto result =
wire::msgpack::from_bytes<basic_object<T>>(epee::byte_slice{{advanced_msgpack}});
EXPECT(result);
EXPECT(result->utf8 == basic_string);
basic_object<T> result{};
const std::error_code error =
wire::msgpack::from_bytes(epee::byte_slice{{advanced_msgpack}}, result);
EXPECT(!error);
EXPECT(result.utf8 == basic_string);
{
const std::vector<T> expected{0, 127};
EXPECT(result->vec == expected);
EXPECT(result.vec == expected);
}
EXPECT(result->data == lws_test::blob_test1);
EXPECT(result->choice);
EXPECT(result.data == lws_test::blob_test1);
EXPECT(result.choice);
}
}
@@ -123,7 +125,9 @@ namespace
SETUP("Basic (string keys) with " + boost::core::demangle(typeid(T).name()) + " integers")
{
const basic_object<T> val{basic_string, std::vector<T>{0, 127}, lws_test::blob_test1, true};
const auto result = wire::msgpack::to_bytes(val);
epee::byte_slice result{};
const std::error_code error = wire::msgpack::to_bytes(result, val);
EXPECT(!error);
EXPECT(boost::range::equal(result, epee::byte_slice{{basic_msgpack}}));
}
}
@@ -134,7 +138,12 @@ namespace
SETUP("Advanced (integer keys) with " + boost::core::demangle(typeid(T).name()) + " integers")
{
const basic_object<T> val{basic_string, std::vector<T>{0, 127}, lws_test::blob_test1, true};
const auto result = wire_write::to_bytes(wire::msgpack_slice_writer{true}, val);
epee::byte_slice result{};
{
wire::msgpack_slice_writer out{true};
wire_write::bytes(out, val);
result = epee::byte_slice{out.take_sink()};
}
EXPECT(boost::range::equal(result, epee::byte_slice{{advanced_msgpack}}));
}
}

41
tests/unit/wire/read.write.test.cpp
View File

@@ -146,23 +146,23 @@ namespace
verify_initial(lest_env, base);
{
const expect<epee::byte_slice> bytes = T::to_bytes(base);
EXPECT(bytes);
epee::byte_slice bytes{};
EXPECT(!T::to_bytes(bytes, base));
const expect<complex> derived = T::template from_bytes<complex>(U{std::string{bytes->begin(), bytes->end()}});
EXPECT(derived);
verify_initial(lest_env, *derived);
complex derived{};
EXPECT(!T::template from_bytes<complex>(U{std::string{bytes.begin(), bytes.end()}}, derived));
verify_initial(lest_env, derived);
}
fill(base);
{
const expect<epee::byte_slice> bytes = T::to_bytes(base);
EXPECT(bytes);
epee::byte_slice bytes{};
EXPECT(!T::to_bytes(bytes, base));
const expect<complex> derived = T::template from_bytes<complex>(U{std::string{bytes->begin(), bytes->end()}});
EXPECT(derived);
verify_filled(lest_env, *derived);
complex derived{};
EXPECT(!T::template from_bytes<complex>(U{std::string{bytes.begin(), bytes.end()}}, derived));
verify_filled(lest_env, derived);
}
}
}
@@ -184,12 +184,15 @@ namespace
template<typename T, typename U>
expect<small> round_trip(lest::env& lest_env, std::int64_t value)
{
expect<small> out = small{0};
small out{0};
SETUP("Testing round-trip with " + std::to_string(value))
{
const expect<epee::byte_slice> bytes = T::template to_bytes(big{value});
EXPECT(bytes);
out = T::template from_bytes<small>(U{std::string{bytes->begin(), bytes->end()}});
epee::byte_slice bytes{};
EXPECT(!T::template to_bytes(bytes, big{value}));
const std::error_code error =
T::template from_bytes(U{std::string{bytes.begin(), bytes.end()}}, out);
if (error)
return error;
}
return out;
}
@@ -236,12 +239,12 @@ namespace
verify_initial(lest_env, base);
fill(base);
const expect<epee::byte_slice> bytes = T::to_bytes(base);
EXPECT(bytes);
epee::byte_slice bytes{};
EXPECT(!T::to_bytes(bytes, base));
const expect<simple> derived = T::template from_bytes<simple>(U{std::string{bytes->begin(), bytes->end()}});
EXPECT(derived);
EXPECT(derived->choice);
simple derived{};
EXPECT(!T::template from_bytes<simple>(U{std::string{bytes.begin(), bytes.end()}}, derived));
EXPECT(derived.choice);
}
}